From b6b4f229e06dda5b3a7b648651d13e79a1309040 Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Mon, 24 Aug 2020 11:55:53 -0700 Subject: [PATCH 01/32] Rebase AIX explainer on KFServing --- config/configmap/inferenceservice.yaml | 7 + ...erving.kubeflow.org_inferenceservices.yaml | 40 ++++ docs/samples/explanation/aix/mnist/README.md | 62 ++++++ .../explanation/aix/mnist/aix-explainer.yaml | 36 ++++ .../explanation/aix/mnist/explain_image.ipynb | 196 ++++++++++++++++++ .../aix/mnist/mnist-explanation-0015.png | Bin 0 -> 572625 bytes .../aix/mnist/mnist-explanation.png | Bin 0 -> 35693 bytes .../explanation/aix/mnist/query_explain.py | 67 ++++++ .../explanation/aix/mnist/requirements.txt | 103 +++++++++ .../samples/explanation/aix/mnist/train_rf.py | 56 +++++ hack/violation_exceptions.list | 1 + pkg/apis/serving/v1alpha2/configmap.go | 1 + pkg/apis/serving/v1alpha2/explainer.go | 5 +- pkg/apis/serving/v1alpha2/explainer_aix360.go | 74 +++++++ .../serving/v1alpha2/explainer_aix360_test.go | 169 +++++++++++++++ .../v1alpha2/inferenceservice_types.go | 22 ++ .../serving/v1alpha2/openapi_generated.go | 67 +++++- pkg/apis/serving/v1alpha2/swagger.json | 36 ++++ .../serving/v1alpha2/v1alpha2_suite_test.go | 1 + .../serving/v1alpha2/zz_generated.deepcopy.go | 29 +++ 20 files changed, 970 insertions(+), 2 deletions(-) create mode 100644 docs/samples/explanation/aix/mnist/README.md create mode 100644 docs/samples/explanation/aix/mnist/aix-explainer.yaml create mode 100644 docs/samples/explanation/aix/mnist/explain_image.ipynb create mode 100644 docs/samples/explanation/aix/mnist/mnist-explanation-0015.png create mode 100644 docs/samples/explanation/aix/mnist/mnist-explanation.png create mode 100644 docs/samples/explanation/aix/mnist/query_explain.py create mode 100644 docs/samples/explanation/aix/mnist/requirements.txt create mode 100644 docs/samples/explanation/aix/mnist/train_rf.py create mode 100644 pkg/apis/serving/v1alpha2/explainer_aix360.go create mode 100644 pkg/apis/serving/v1alpha2/explainer_aix360_test.go diff --git a/config/configmap/inferenceservice.yaml b/config/configmap/inferenceservice.yaml index 6778ca6d78..1f92434dd3 100644 --- a/config/configmap/inferenceservice.yaml +++ b/config/configmap/inferenceservice.yaml @@ -69,6 +69,13 @@ data: "alibi": { "image" : "gcr.io/kfserving/alibi-explainer", "defaultImageVersion": "v0.4.0" + }, + "aix": { + "image" : "aipipeline/aix-explainer", + "defaultImageVersion": "0.2.2", + "allowedImageVersions": [ + "0.2.2" + ] } } storageInitializer: |- diff --git a/config/crd/serving.kubeflow.org_inferenceservices.yaml b/config/crd/serving.kubeflow.org_inferenceservices.yaml index 322fdb31a3..ad3d37c9cc 100644 --- a/config/crd/serving.kubeflow.org_inferenceservices.yaml +++ b/config/crd/serving.kubeflow.org_inferenceservices.yaml @@ -50,6 +50,46 @@ spec: properties: explainer: properties: + aix: + description: Spec for AIX explainer + properties: + config: + additionalProperties: + type: string + description: Inline custom parameter settings for explainer + type: object + resources: + description: Defaults to requests and limits of 1CPU, 2Gb + MEM. + properties: + limits: + additionalProperties: + type: string + description: 'Limits describes the maximum amount of + compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/' + type: object + requests: + additionalProperties: + type: string + 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-compute-resources-container/' + type: object + type: object + runtimeVersion: + description: Defaults to latest AIX Version + type: string + storageUri: + description: The location of a trained explanation model + type: string + type: + description: The type of AIX explainer + type: string + required: + - type + type: object alibi: properties: config: diff --git a/docs/samples/explanation/aix/mnist/README.md b/docs/samples/explanation/aix/mnist/README.md new file mode 100644 index 0000000000..e4cc97e040 --- /dev/null +++ b/docs/samples/explanation/aix/mnist/README.md @@ -0,0 +1,62 @@ +# Using AIX to get explanations for MNIST classifications + +To deploy the inferenceservice + +`kubectl apply -f aix-explainer.yaml` + +Then find the url. + +`kubectl get inferenceservice` + +``` +NAME URL READY DEFAULT TRAFFIC CANARY TRAFFIC AGE +aixserver http://aixserver.somecluster/v1/models/aixserver True 100 40m +``` + +Query the inferenceservice with the url and append `:explain` to signify the query is asking for an explanation. + +``` +python query_explain.py http://aixserver.somecluster/v1/models/aixserver:explain +``` + +To try a different MNIST example add an integer to the end of the query between 0-10,000. The integer chosen will be the index of the image to be chosen in the MNIST dataset. + +``` +python query_explain.py http://aixserver.somecluster/v1/models/aixserver:explain 100 +``` + +## Deploying AIX explanations for another Image Classifier + +This section is for users who have another Image classifier which you would like to get explanations for. Change the image from `aipipeline/aix-explainer:0.2.2` to the endpoint of your image in aix-explainer.yaml. + +``` +name: predictor +image: +``` + +Then deploy your inferenceservice. + +`kubectl apply -f aix-explainer.yaml` + +## Deploying a Development Explainer Image + +To deploy a development image go to `aix-explainer.yaml` and change the original explainer image to the endpoint of your image. + +``` +name: explainer +image: +``` + +Then deploy your inferenceservice. + +`kubectl apply -f aix-explainer.yaml` + +## Stopping the Inference Service + +`kubectl delete -f aix-explainer.yaml` + +## Troubleshooting + +`<504> Gateway Timeout <504>` - the explainer is probably taking to long and not sending a response back quickly enough. Either there aren't enough resources allocated or the number of samples the explainer is allowed to take needs to be reduced. To fix this go to aix-explainer.yaml and increase resources. Or to lower the number of allowed samples go to aix-explainer.yaml and add a flag to `explainer: command:` '--num_samples' (the default number of samples is 1000) + +If you see `Configuration "aixserver-explainer-default" does not have any ready Revision` the container may have taken too long to download. If you run `kubectl get revision` and see your revision is stuck in `ContainerCreating` try deleting the inferenceservice and redeploying. diff --git a/docs/samples/explanation/aix/mnist/aix-explainer.yaml b/docs/samples/explanation/aix/mnist/aix-explainer.yaml new file mode 100644 index 0000000000..98203daba9 --- /dev/null +++ b/docs/samples/explanation/aix/mnist/aix-explainer.yaml @@ -0,0 +1,36 @@ +apiVersion: serving.kubeflow.org/v1alpha2 +kind: InferenceService +metadata: + labels: + controller-tools.k8s.io: "1.0" + name: aixserver +spec: + default: + predictor: + custom: + container: + name: predictor + image: aipipeline/rf-predictor:0.2.2 + command: ["python", "-m", "rfserver", "--model_name", "aixserver"] + imagePullPolicy: Always + resources: + requests: + memory: "2Gi" + cpu: "1" + limits: + memory: "2Gi" + cpu: "1" + explainer: + custom: + container: + name: explainer + image: aipipeline/aix-explainer:0.2.2 + command: ["python", "-m", "aixserver", "--predictor_host", "aixserver-predictor-default.default.svc.cluster.local", "explainer_type", "LimeImages"] + imagePullPolicy: Always + resources: + requests: + memory: "4Gi" + cpu: "2" + limits: + memory: "4Gi" + cpu: "2" diff --git a/docs/samples/explanation/aix/mnist/explain_image.ipynb b/docs/samples/explanation/aix/mnist/explain_image.ipynb new file mode 100644 index 0000000000..196d40e9f6 --- /dev/null +++ b/docs/samples/explanation/aix/mnist/explain_image.ipynb @@ -0,0 +1,196 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## KFServing Model Explainability\n", + "\n", + "Install the necessary libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import requests\n", + "import json\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "from aix360.datasets import MNISTDataset\n", + "from keras.applications import inception_v3 as inc_net\n", + "from keras.preprocessing import image\n", + "from keras.applications.imagenet_utils import decode_predictions\n", + "import time\n", + "from skimage.color import gray2rgb, rgb2gray, label2rgb # since the code wants color images" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pick an image and wrap it to send to the inference service." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "test_num = 1002\n", + "endpoint = \"http://limeserver.some-cluster.cloud/v1/models/limeserver:explain\"\n", + "\n", + "data = MNISTDataset()\n", + "inputs = data.test_data[test_num]\n", + "labels = data.test_labels[test_num]\n", + "actual = 0\n", + "for x in range(1, len(labels)):\n", + " if labels[x] != 0:\n", + " actual = x\n", + "inputs = gray2rgb(inputs.reshape((-1, 28, 28)))\n", + "inputs = np.reshape(inputs, (28,28,3))\n", + "input_image = {\"instances\": [inputs.tolist()]}\n", + "\n", + "fig0 = (data.test_data[test_num][:,:,0] + 0.5)*255\n", + "f, axarr = plt.subplots(1, 1, figsize=(10,10))\n", + "axarr.set_title(\"Original Image\")\n", + "axarr.imshow(fig0, cmap=\"gray\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Send the image to the inference service." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TIME TAKEN: 47.712029218673706\n", + "\n" + ] + } + ], + "source": [ + "x = time.time()\n", + "res = requests.post(endpoint, json=input_image)\n", + "\n", + "print(\"TIME TAKEN: \", time.time() - x)\n", + "print(res)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unwrap the response and display the explanations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/site-packages/skimage/color/colorlabel.py:111: UserWarning: Negative intensities in `image` are not supported\n", + " bg_color, image_alpha)\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "res_json = res.json()\n", + "temp = np.array(res_json[\"explanations\"][\"temp\"])\n", + "masks = np.array(res_json[\"explanations\"][\"masks\"])\n", + "top_labels = np.array(res_json[\"explanations\"][\"top_labels\"])\n", + "\n", + "fig, m_axs = plt.subplots(2,5, figsize = (12,6))\n", + "for i, c_ax in enumerate(m_axs.flatten()):\n", + " mask = masks[i]\n", + " c_ax.imshow(label2rgb(mask, temp, bg_label = 0), interpolation = 'nearest')\n", + " c_ax.set_title('Positive for {}\\nActual {}'.format(top_labels[i], actual))\n", + " c_ax.axis('off')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.4 64-bit", + "language": "python", + "name": "python37464biteac3a92cf4cf48d3b00e9c4589083555" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/samples/explanation/aix/mnist/mnist-explanation-0015.png b/docs/samples/explanation/aix/mnist/mnist-explanation-0015.png new file mode 100644 index 0000000000000000000000000000000000000000..d32fdfd64c607b6e5ed38182030d79a57d4f3623 GIT binary patch literal 572625 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

tXpN=Un8j?*DQ+gMy4X7dA_u0!x3O6QmCS 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 JIISZMaB7a#f=spJ-VQ4m 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

V}xVA4tm=Zb0 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 =5I7Bi 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

G`>#c z65Gu!#xHnvdKQy*=9!X~NlzKlFPh`ZF{q9vyC;#5;VQ~?uP6RZ@?}c2vLeA)C!ILl zwnB8_oh#1c-*w}d2blu!Z?3##?m?gLC!w>0Q1>j=(EC<$m=hb?GjHE>+;K;XcQZ=YY085B}XaFspsJdjMm z<~JqZXpx-M*Se>DqPDoYCi%_i41~P@K7a8z7q48VUzbUC5P|m)irlo&p&v;JLWpRw ztKYL5kfps*5$64xUTE&aki&hbN~k;$_ID|8{pfa;ksEBariOj9(=X4awh{f^Hx)!@Nw}DmmB}ojHM8$pX~w@=i@kRK72}w^3zmgX z=~LuQ$IsKH-)-FY8*uxQ28_(w?l^JRXB6c9ebZd@bwC7{RzEe=wu0xK$5UF7jRh~U zq(9Y+ZS0uJLoaa0HRdRRRqjm#_;ka0@0lYc0+YbNf6}zyWe??{zR@$GtEO@A| zhDR6z)&u0R%6%7u7{@@(f&4_sdxOWji+g}+;1z7DkvA|^CdfUW8jJ(yTF<91qWp0--fY-$`y*@#TEQh^_15ZUbT9+`8W-pD(Q-iQM3A%VGAzj|#1vFqoyZo7ZgI4pP zqu%BO@?v0iR;$2W)NEJyD~HO@d8=$5qEGiCVf%o-_!q|j7^-Q(ZwShvP3NA4nh3I! zJxKIsRCj*NURBPXC%l;H!?DHz5jXed%w#Lr!w++toYk)0+_S9v?d-p*DjtC+$Lh27 za{>Vvscq7rerz&pp`>FvXe8Jh(t@yykDr0PUJLCj3p1d7$0LD-ZSNmj#y`9Cn`xf8 zD#`{-!RcqfXc;B`fD0zXvOW|+VLD{;>mWYb1odpEZZDUAO8+(fU4T)lNdVZO2Te>8 zxeN7n6LuDE_S}5>sdIEZsl}`9HsdMQ4E}Bv{{O~712yP|T!sgmeokr8ABkq*@@7<6 zAxe+!FJT}KKWJ`&>{l4=Ju*esc#vN&1_zozKxn+P0R_QcD^iy@G)RQ}9u;FXOmV=+t79C=))L9+8T5}O=v6p# zBZ$hgaWKs6vK|jp$Wv!ED46wmrFRwH3($8$AM-l{SoOZ1Sok(f?@fHyJeb{$(_DQp zR7MqyHT-DPQ~4WEJ&nyOaV>@NN_T89@G;o_w5HzTj2cF+Q9Z3hE8Jk$^+1(&18paAE_VzGD|vhx3cUDXVvc!Ul&TEM~uyX;d$&b z>_@6L>yHDZeEHxbit0rLV}oRbPD0m&p|?1`HB&AhA*s$`#H9+NQ{%rfT5K<%+n&Y& zOHZC!Q$H-UJ$}7-TKVPhqc^KqZ(PEAJrWG$*oDX1MhaOdjq6z;|0iJeN`uN?riv%??AD;K*~^ z-hli2?*qtwHwXU@3qZWT_8F$|Clo~huwoa)CxI02FN$dHUV8}htV4pU?lwoCf+3xb0(@@57+bBA zXdhe(wrjOgo*{CRifp;_c;-EX8b|#XH7)}a(lQ_A%rPSDUt7gVqstm;iW%o+R{EAT zKzYM&X1veTrnc>%1H!PpNp^9s`;qI#aW=e1~EXq4>TTneEER}uBeXLrM zIZ%KQO42ULwc(a@6cO>&hwwqbWRdRf1IF@QrDNwiPT#9vZ4rW_HEt}v_QF3uvrkTA zaRik>zxQ@;uS>((patP>8IaxgB)_n_ER@AC(G_yXW-5%s7)m5m*2B0*^kA}@WI6Ut zcB3q)7VEHGD)H)>wF;dh#}z~uH;JWYVN8bL;#HXgG!R@|t(ifjrBA*nsQx>!?ic0c zxuVo?T6wj9KX&P3wTuqI1>f@iyLS3tqPpcu5beu4U5LXsVX>A;~>b=f8TO9I=-FubK_)}}>i^y>i#-V2UtX~`T26@Ag$b7P3F3RL;b5!EEii8q`Nwo4w4#H?3luQjJrEKgbrW+AfYNWss8{ogsK)`oXh)7 z(?8-Njmk};|41~o8Ga_;@k|SDE04<6CMm%b+5GeyOkw!P3#aC>?FX125dh`Zry$05B0W#_RFRj`oS4tp%tZc;6#8<(nqzz#ffL$o< z@I0$T{IdcR7ob_kA}URuTl86H^n>DC=2Sd8U(7w-+Tj!$?IZigz5Bl}QyABAWOJKD zb&2FJqr|E!__=0m(c;qWX69>8jaT2yNBv`%7aBtN@t$6O@IrpVC={fP)Wde5b&L_b z{0Aa;zX6dqDy%H%uDK!B6w~O4UQup{?Tn`}hnw?EM%zaTWq8<=kE~l}@(mJjLf8H= zxrWmUCD9?8{C^1WnLaTBh4bNCsWRJ@MR!TLR$!MBLtN9CrD4cn1=!|cic=yvWBqr> zeNa2z9Vl5?IiF6K`Eqs+{wn=y%fBLh%v484l-e$$gnL7Fw>iEz|6rG5Hq1l6wXp+( zTRlNUR;oOF%Kf95n$kY~L50*e9Al{m5_PZhBgXnnQz^jAD@|0*tDCNSQDyf(%K8K!M2%ld*d3&&NfiS4=8BT(KvJVS%1dTRJf~}lUA(2i1&atmpxzKk*t78p0eAMJX!4825_UG z!YgtJOFnjJXk0_*ccRcbhUhQJ_xBR-kuYW$i@6p319#_n2KJJL=-Be%tl+T z%^jm9CuY1O{Gfj%=Ij<1dX#)hDB5aTR^}rda(QwmLS}+9gY^ZGa;sdwj`2U^k-eY7 z9LdGv34Y>V^(>q!q062gbiJb!9qfYfy2Efemjg=ib9fSjDm~|m43&8=9R+wW!%sZC zjnib^SdPS&U!|aC5UA%>jMIfRvAE3wKB7^F^rC|{kQ5TYLJuaxVidJwv@^Ue9F|Me zV_OwB5tBX?a7~oc7-6SXbfNIJg1hgfkbIK@=y9@nhbMRVcAIItIg7d$GXa>#_1HVP z^Xl4P%@Y4yXSru0lgaL~x(t0WSgIi2Nsf++-NC7H*WB{|+VO`VI;%-Ad|SGG8e=W= zBx(k%-US_qY6CBH@lJA1CIudeRSFe|Xv;hulkEjRa&7>R&wt!kA>OvJn4rn)1x!nj z^ua@edj%ljPk@pHiK@q{%K>fo>^T@eYE_ zcq&LoekF%w3xFS70ehkYv!P15nSdt$(Ote8o~DVk>>znS82H6wq$gwDd)12M?v#e=}ccee|$xdVnn)d2lWW$<>O2e|7YMB6#AS zm)iv-!i=j?(3zwz`dUyNVK)JJ!@)U8-4_jD3iZ~)s_XRt3FF}_8bwl>*;_JM-{?qm zTdz8$S3f?Lp9$b{0aN$3b%-vGq2`(@gsoMk$}3<^Qt^+dQ&VMpC|ygP(YbL@`vmpHcXRZhh78)F7DU zkMlMBDwbqgZJPdNpGtbP*|C-9Jn=<-%{;lb_nn6TAFRU1IN6jL1_UZ~IN30q?3Qb< z`P8LGe(dc!pUsH*C@}ph*qfB%2^5LG#B%CkxssH)0w<9uk`^LyM)k?lz)|`ix4~I( z3u$!{E%9s}gZ3Lo!N-TP!7*3bYG$+(s0#bvUwQo7+AqHCSxm5CaPk3RY{_vyb?mbA ze7(JrbKNx`NV`EXBPV(2h!%agp$LJ!=4nZQgaEQA?hUSuH{|%KjlKdtRPh}bTv1aF zw!E$`#FY+IER)FZr>Kpcb!u6XVwlD4nQzw=`C#`7vuee%Z548UG%dlG?myMjzWEyM!GCk`d~8>f zp@P`lBom6!`dMh$@uDP8?-T`#NrZZcaiWT#QKLNUI2u7Q*m6O0N)3k-S~lMY%>{ZY z^eiF<*#CgJK#A8HeHr$%wOhqN69ylE)kzQw<2^TdAD{u+x&z453Ec-d(8NXg4(}jRR*<s0c<2 zz|3shbUBeY2}fa%k`-bid~{!80UbMBtOCbgAo2#}wcm8^I*NGwz(g&^)Nrvj`g%X! z5V#hN@HZ7+bv~#+2iK&JhaP^zsh5^FGkn3*eQY{1cQNtp^=t7oJ>3sW)&$Z9t(a}* zSFo?oO+*f#1P1r}upGVIKJUK5c@%IhhQ7yq@N1~Y|4A+erRTE@Dwn$-j}5nwj%Q#W zHsLm()zWC$B0OdHjFW??jgJTWDA)drVTgz~r7_?wqz#_OTBV(of|8Q_jSAd^Q^KW5;vnfCYf1!Z*(-TKNt zsuRX_kKntzIn((}+@pZkKTYZ4F9g7k&7YEdS_^4way_j@$SR(U!juilazAY*P|w(5 z*z2HTxpLwP3sF}mBnTy~Lwf8E%&9ka{sJKH$=d6(R57K^{;a*WwZ;1sx$Z2)>*4|6 zq4cq<@2_wQV*w(J`HQw4W+hTJfk6qQ7XmWR*2ubR)qnU9Q(Hm6knF+xyM4$IP<67h zHhUQoO!bX{TFm!n-Kq9q$=dGIa&7Me(EFL*sRpG+B4RS+;Plp+->73BvOyR~dM#E6 zC}GxVOFORooInnWH9yokCgCB(93GAEHn-&?vK}_sp6*s^I@P8e6Fw4^djBXhZUSPt zi+bD15w6aU0kBi}p3tw=`&pFbaMaV0T5#h^QV6vNgM7*?vHt$tT^OS+1FuiFN^w$6 z+rjmFL|RbfoxU}X7Hi<{-C&MG*Z0?hLiW+Vaz&awP6_8=2-*R zTp*#1IV+PgyEmH|m*1onxj2eIt?s<~CrD#fnzsy{SEwP%Ecrfl01uPD9vcC_?p)l`_xAMCsDVnaVl3l3Q|VbXmoV~|&nzX5C0{ts9?g|b&J zK_j)G8bUSC+@ZR4hw_J`(zR%A#$w&OTkz?+)j-b6XVM%~2CfDl5CIb-drcJg5s* z_-xRANkFOc4f(a!<{<7xhQMtXnI!21mr?vj^LB9;^o~ibvY3OPv6GBsZpW|$8T7-c zX0Nj7&&^(Jxj%%3>6e#VSE-B*-@E1XG3foVEw_Bd1jc_*9It7mN;@bPp zJ75CJ2hV~*D|dZt>DIEgN>sRX1S>K9@6SEbe8f%~sD%O8yxGKGb9)-3-b+lY=5AVLvJywEH z+{4v(#SG{Dj$_XdE3j{;`xV1mEKgM_`ScHA&-m84%;0zKJbo-9V^{>^#z*g0etvzn zLDrwrb|cf3(TCFsQ8VyVLoW(KaZ#i><6?!06D$eyPCdSHy!IO0z~}`bW%2|no@#lB zs(y4G)U{py;B)`}+WUa(dUv$Uq=|$F-K1}VjVPc7QX#~q=ionmXI#=sz;&+9g!&#V z&N1BLQ#|h>#Xq~R3>t~apB&}9NbH@&=|b!pb>A^bU6gX`5eBe9i3OJ5A~x_u7mNF^ zH=hWRo1DHhDG*2*8595B>LhcUEtKUT?7eV_Hz%igD^5M5V9$rqZ${P@4^`FGCP-Ml zD~2s}${#vBf0aeJYzZy7a}b=Jle-&xG{4Tl3^m%~RVFL@-r$PEpPnD(=02@G6Ub6P z_U+DFF!e*Sg+9YusvPBpYaz4d9k(yV#Y5)0zZ{ZTZ@Io9<5bCvzr<_gG|M1f8;wW5 zuIQcE_tq{lF84i8gV>@VYNHo4zpwqlhojM@Hso@@{b{y`L=qd7Otu^&0m>Mq{X2c5 z{hG)!dO+u|v7{pYzyAn&aHz!hCX+K0l(dr#l6O46e91*6#d}U1ZwTf*_4$DSBrSz{ zcN0I<8dZYH_R$$hogR0!{Fqkse9&gelMAkNrA09lyMXcj+3}}5XLr=0DoCdH>0Y=UtJ3aodD!gSCWgXRADQ~8(0_*RSC>oZ z4FVn}2(CDP$S3;vEKD|5nml2TmH+Xm)Uxe_y%g=8-xkuwni=|*6sNB)j*u(I@GEuP z@5%S!-mf}oJ_|nv8ks93k65w=5B^BPo?n`a4R<)>R&WWo^Q&CDwNgVU%^NW^e%;Rs z+(p4TO#M!1T?RS5?JUq%h@9lv{9=p%G>oPV00$80$;C(Zu%e6oQ`geB_cgR(pFObS zR|ef%Y!G+o<=p-u?a8M!QA)`_UN&r5FI76G!V9A>a73F_k~XQe0Js|fPu?Az%rWuU zB1`dlJ>;VPD)LtgQmKvR*+_CdJd$r2RuH*Fa1N4#^8=96Nc>5~oP@Br0D*2zavZ3i z23igp3RzS;+rR$FpVysNYP8lY&6-e~{>#5>mHP`ahG( zq&~Y5B29kcS(9%W!NkF<@oDGhv@6?@TFLbJxKL(k()fN( zIF#NSs52&K@myoIWeF&*O&>>vlXoqh`+R;$$)G+ihevm2x5FQ8C_dcx#61H0abocX zF8XaFZ^@Sau@a+X#dJ=23JH%tlcN2n%x|ai#(p6MsL2j`yW_~;UKEG%Kc{k&$KarN z8k4G|oar=2)t%-eB>O4sIY?n)s1ZM0pWs#Ywzh`cCx2 z4-Xx~b``2&#oS8-$o0o7FwTn|e?ICFurBVP+vHPJ2j<6&LY@f>T9Ma+3UuN0NSVKi z<-jxJP-J1SWSMe8BXwEKo%n9D(2;75vkMS^VdJw`T#FR^BRUEy`!|Ih%c%TlUoyKuXq<2c_kj(NVPfYyyz?*oDCDGUoALfn z1?X}2oQL_ll?N_ozkd@#BZ^_UicJQ>ITuiFe}eBV4IDC&G~Er`zI^uf$~63kol>8< zcb3}$WXrQ;d4?=l04t0ehsAQ&z&e}oI1y_U%?7!VzZ?JX2%pXz#t86>_%+7y_S z)q@0hR;0!Vp|{^>#&Cg1Z}9xM^?q>t6Tk?}ROcMZ&az{ARMr)3z@^(Zv=A%m+=f$U zdM^xY5pFqh4twa>Bkg?ZGhZ{|C*D3NH{PZy!wh= zcvG+o@1%fXgU#(VuB6Y1PC&Z+PmNUrh1UB1vUJ7i7@&!6me(-(@d#b!^ww(|8^5K)vmZ8< zRQ+nZM8Tnsu3bWR)b1%M$(ZYMH2<&cM0Xy3PokmzUiD`)VXenbT9QJba3 zMZ@!urB~N^So(=4xGy3#4*9WU;~T?!!pctGefZ>%!cYnE)@OQ8(GkH(qLF z`W|_f>)8$hjKn}x>~cLvGbh3O*DfziSe?=n{y;qPRpiPFoB|Djx^tV1JB9V^QPyu& zob)RIkH#+bKY5pK)we6B!3LVRAdB-L&=M_)iq`#VJH&PGwfH^^azlCgO>jRU}r>e7t99_J%sVher1~&*TjSG4N#+I#j0#0*@JGt zjfi7lGR-XK_Gq*7@Nz}_L<&4M{#MRLCHyDtC!OUHlB~kh+>58XhwDm>TccQ4G$CZO zysm`b*@UN#iDW&U&U){H)5V>&#H(eMjlpR%(16jW7JxGq_-^19ck$T$ZGm4{{A$y4>hxjwm3|aDe?J2rlP>)7k_o! z`8winGG4QzXCjUc6OXr(^N@Zz7`JKkxu<8$j4kZRI|$m%2Y!xZ_1~*s;gSi?N^Er@ zyK2H!5T}q5EMm%Hp8xwjm4bsED7kb=yWFtlcT~ivLE+lOFkgJHutqBK1JF?-J>&O0 zfC!VFM@d)6ESsExHg|0JA!d@<&ek=kW$@N}1J>?_!5&|^PA|E()`|EJr@Tq~5dL74 zg>sV0?4&IjP)=+qpFlL!0gaavrcI!@5vas<`2_l;7QH{F`8#L?dZpfw^!E?RM2$xg zmRWNX&#a1RrADvHPW_rJ#E9&YR@^PHh4w9hvs7Tf+JYm-AV8b z1bj>TSv(U% z8bggj-+A;s*bcs2sK`CQzaSr^*;tLEd_bz#+cGPmF{AO6vb)jW>&eZ;RX$y4?Z2Hy z5+C!bobAmb{%6&SFU674jM2HndTLGu5UHF(&LvC7qBg;si!)!u!I`5S!-Vf$2yqSX zv>T5^Dy!3XgxVi`g)%-j7A~}m5&VO}at@4{gHBPLo_G?4FcyBu#oY}mPdMeBz})hf z8@;+q`s9(z-&nvPf&4srr?0mWMjeCMDtKh43me}!D8IhO|AM@hnr-vd21tmdzUIjS z_w0Y2QFta3d1mu|-})^WTSki>6hY5|x0QIa6U>5xLXpu8-uOMDQKEE117k3iYN_ov z+A`_-%=Zm-ANal3B$YUZ-GitC%O(5*-&98`@75BdSHeSw{26KBx=pm2;NCX>ZL17d zno{1Yrq5mjk59u{%D$pQVx0Wb+7^lR}G-*zZq99aI{O% z!|abijJyuqfv7Zonm!49B}dEu3}zHn=|4#4NAH$`EumRw}Bt9!m?fD z4jkrd%il{kI0ZVMLTfP}kfZCt)ae;kSoiQ2whRo}hlZ8F_L@YWOV^ub=zkXg8de4$ zS9lqu%Llq?3Zfp~-QHMk|Z_x9PnPI|9bd$flL`{h$1akq;r*tHxYoP%pcAF2)e z2?c*u^++K3{}c-11^mHmR@?{ei+fEAy|9Cb6T@`S?VH$b&y3pfA6k?*lau{sJY2q- zwN!i7L|0Ift79`$kH@cpnVLCjX1!aBsqARK_`yI{C1a8%k4AC*d7E{GR{Kav@18xT zKV=q=zQ#3Z+$gH6)<9H*8O8v&&OU3nQ(xC>ThY(Du^Hnh22$ueRW&2R!IDj6^#VtOZYYh+qU;H~Van{QzI z>Y%74(63R}RPRODQce{FQ=;o>DD@Hh{lnn!)=S0vgT6dnT_NHUyH?#=JYNEmIJgC1 ztRr~R6^B~Fq7Ha7f6QquHqAB;L17(diA@OGpM;pP zbq*>6xR5=>W5GRk?F@qnH8;US#24Y|clmvsnLfwD&frE;t7c^mu!O@%E)!>=D}DnI z51ms~E!)|s|NS5z=}1GR80<_k#xQu%Pz>YZeaCJmW(;F^QA@UL(+0nM*))6?J-}IU z4bj`CJCpt_glVHU$PQD1~+I!E9JVM`!JiLZJNRT+9k_llp@I?1pOZ{BbcFIKo#Gfk`Sfqv4)^n``r~vOl zQFijN)C95~w~_oB&fn!7QS@@)SUoB8X?Yt(7f}(9(<3R;QG>3<9K(p&g3lcrV+$YR zUnVBo6Sm>*NQ_;cZ&7JR)J!LAyB`XTUDE`ko?G;GRG@|iu*&NsdV>5dp58w##eDK-;0g9gUPpK zq{AWWa-$1Akak6E#h8$J*aE$l{I(YzV)e=BRjgZgNDBf4+ zeQgWgPapCBbn5oLetDALEccadF}BIt?T7Ziy4qa-oa;w(SIg}Dp5h;rI*Plnjoo8; z^J$g0rSZwA563m^m*_R`6~ZE$@s67Je@2Ir>K|_WAD#RE!i`@Ab^cj?pa4mXk(MjT zZy(WkDqdCLTJ1t`^7$fhAId{+>l;`(9uW;n!pTtdVIEfTe-YhIBc7E1x=5RS)5Eu$ zP|zJ%jLCAm0v2>nJ(w^3)D*(SvrE;IRK_E?Zs`*M$Y*tVH*}`^U*_Py3`>yQIHtcuK78CHhS-84agJ#ad-)6=OsGuT78(sXnX zYN4N#>QDrI9#-1_j?7TDAW$bHPY2w2+%OLi`}1Pg6O`dC^^v zHzxD>$bU%tIwm*Gtj`5vs{g};zX7UqqMuU=Lqwl}8xp#~64AW+3p+cgkmUfl-8lZ` zqw}f05mZ#&8Gg9E8z;9xVCHahkC`X$79}W3`~FK$e`oCny%%2p?W(mXyInc~#K2|6 zwn8Z34DzXGQxlf@p4dZ@?mC=Yh+qOc~79KMOZ6!ug8XawU z5+T|S>?QBm#JH^qy6a9R?{HabB{fO6=8iw0mS}%hdt|k=+UO4D3Msq~Yjaq5E|`B@ zp4?9R^j*_5_}T2Vu+y@kd2MssKCeUw*ZT}EgGrMppLLyKm1GIwlZ^+fIXJKl`n%+# z_hfBCanyW3?NEb1 z;ML8&F94LFQaF+{xJug9rd;UF;C_WMN3VXq2}wX&Cn|T6=e|5{n66NiYXVZw7oWd?s`=(SlkOr zYeJYekU9lVxV>%EM0k->&F>cQ)0STd78-GrRk>SZ(%CBK%z=SrTU_I z3J66czx8ShaPLw^9oMew3$;(9;n9$)iiTG8`ULwL?r>o)ID5nd&F-}gcPHoLBmrQu z?uII!+k3hrVLAvKD5!pX`>fD7DV##{AKl#X5_GzP(+A8N!ojIc$bL#-`E+u@C-^uz z{%mH~aGx)IN_TXpcp37`KF7xMThEUu(gomiz`_IuaSPLX5I{nj7;9euXbaJ$QjFRk z(Q?=)t=sZ{(PVF0G!TFKjrEq#U;&bg)9i6bFZzL6{goD$1`c;9p~)y|G&XZLEA#Eq zm^UX8THlc8-`@xctgFV9#cx2sm zFO(PYc0K9|6KP8kL7^YWrUSbyM3~*{Wwcz%hNHNU?C;}b;_kkph*;B?@yFT(ui>cN zh}UVY=9e&q2TYl3^;P9x^&W+aag%3#5CcwvqsLsE4r}#+{cjr(Nf`Eb|BHbYk zO2`mONQX2GAzex%F``I!hjf?2kOR!jKAY!xpL2bGocCPce_n%*o3+>MS!><*{kx5> z0JQ1J(v=|~GuYPaI)-%~__lYR8B+xX78rxEfui7dwHX$gbPU_Vc@JbGm-@4|ZdR|b zEOukB#$g@OK~qH9w7QvTYNo)^Wn6+`Ef}#z1e~{QEdsT9OIO%)u$F57;lc0}Lkspg z_W`&<1q^-r3rPi*&}hI3dQfc-K*1~rY3{1hfJ=SY%GU)jALkN*#l9W##)Ok>%#XGM zZJ0g9ZYHQ%81`5+qdB`L%c??*7{fMp-q5td8sw?`EWzV|bu zyZq8DjP1HkYO2yrL$2G;%xR`;8+bcD-Z1B3DQ_z2zj0;xW0?}c$Wbv+ry}wo?vVqo zrnmdf7WZBitwnC?Z!GlOvuQN?(J$&W9EvHL{DisF=+LXw#UC-Yr%{a|1#dy_rM5V? zt8&9DB0fqct!WqHb?aI4NsUL55>T=ZV5x!EfkmG_#g|N+)RLV*qBsxFu}!bdl`m|* zL4E2soW=Chrarb=?V0So^+@;d-!ub*R46;n@jqW-+*j0L1Fbu4`09fsOCa<7NM7};p-N0&#vlpz)K9SA13bIdy zRS&qh0(Nx`Op(CGCx9joZagYmK%0?V)i2Ic_BSWib9t~^<4?D;yp4AGM-pFc-{U9CF@iG ztVPjC=^ndd>TBb8N-wNnaFN6O*C5m($&=*Te74-#QsqkFRueS0Nc+*Tu3};NN6_>m2KcLsy;)32b!o4wOkP4f=S&hh z_FimRFpvUneTxs@kZqQ_L~2@<5?|x+cDD#ck7~U?g(aC0_juOooBSXxOanwv2!s2M zMUjwi_imQ1)k{^bf_Gow(*i;^chtW(>p&#Dd-2IPc49sSkj@(v* zS=iKgKm7#P)4=#;D0MKL*vBV};e`RKMAe%!(&MO;(;_ff_(e`CyTvm&(UuG!5XxxPI{x83dR~vAVZ;0=52yK! z;aB4&HqylZ;mkYT2?Fk{LgxK)j)OL!G(!xFBAt{ytATW{UAXp-b!S?f0r+tv1a8}1 z{Auz;re8PDZ_uW+iXD9J9sF#V&!z$SAe{UDR#1wU3XV-5uh!xpEf0&aAZ4GsBfK=C z=jWWYJmufvh^+LBA)rip{PXAZ&qkj=e}2Az@osdk_ooR9;L4H@MEen{Hi)+EVqxyb zlZHsK`CJ&oEv1(oInp+(ZmSr`Mqp6!Y#IX)2llByu7zQ>7xW8WfV;f@kS%5bf9%2* zYB*R5Av0n#56F?dycB+%N(CLRmETEy0|YEDvm#;0<4N^^mQv$D#%XA4l{v{sT+CPO zVSQPay3Ck)Q2%uvT$M^-En^etA+Bvbl?!Zj1`5tpoNyMR*BqCeIV@Q@Vx{%pb!hzs zn3qi!Px9|_^|pk+kL|QocwuArex*B;(>tEeeAtKi?;-o0-!I?^&je4+J_T|dUR6I)Jz8exM;}SP|^}lKXZS`=NeUacy^YJw72#T^kev6_q0UJba z=KqAe`Fr8{kOCjrYoFZhhxc{@O(lQw@AqN*A9Bs;LAE|1^uLl)Oj3}6Y5MFTpMwqg zMqb~wla2Twg;a;eaMC7oMa?8CQwvLH6Gqj3;|zMe3>G;<>9i%dB{JS6o$+Eq;lYa#AWgY6LH3w5PTywOkE(#^sHu@P}Q-}m9@ zCE=C!IiLl86_$l)#lTnj&?o(s?V+KYe>Qden$8JEImHvSL4ex_6uaLWeV`rXR*psuY$^n;{%TVMi( zuG#O*gDQV8IUb7ah;#UGcv~9ZFG1S>Ce6X*QP9|M;F%|bA-dS+)%OQ`OYgy@#+@qM zb8nz|2vP;bj2rXc6%eEVd~a`!I+;D%J{>d({}bJkE<08;L8(>Tj7{1bCSXSY{{?6 z7o1i{EyN8UyM+#z@ti})!}O0(1U2{Qgxp=DdVRr|!@`lE(QJk=Kj0+#ZV>Jk!<|e_ zDtc|A+rB05j(}9dV>5|A!H?0RaWn7qwB>&}9iuKjIJ^p}K+QkoZ)STTBUDaGRtl38 zXE(kQ=ydEE(eLl=s1KIoE}kr;0um?VZ76&?&&%Td*m0;727gQ-^?F=L=wAA~I!5en zE{)s4Eck4JUsCJKqA-f^syyR7T*~u?w5(}HVB_2i&CL(A$N*7_LeW3o*8pz=<0Lbr zVawsD0$rcDb!{a_cXY?BEBd~G2suXx*?ZuPGksehl?UylnJu6jGXY3~yMsil@L@;< zSApTlv0TujN}g8%15OSf{COz8L{Uv2$ld!#4)+A*@G)lF#z*g%6qy~l8TpRYgoJYc zyBJ>VJht{@3eZUCv$X~6#X;#kM}_MyaQmX466wov75VjD9!tlDuM!v`%~FooT}&sZ zNVFt!kPvGv#4!SxWrZpfH?GZKVROEu@!*pB<1L3yyz;r{!@v~-uoFdAEIDsdkJ-5` z&W||k4u^5Yn0pG;ujvw)(2S6-e4vad+Y`&WQyes^~ zuKPIsSjVaR#r=fY=xxDI?c2?Q1&%`*14fy6J{kbtYx7kGrd_>{yjnj4X5zzRUf1a= z56)iTa+_0K1i!j$(UsiFAz|Kd8CJz%bG1n~uw^jt^a)gy9KbGNz!OQe`O_~iFB#^x zdsF#!ncw@I*A6lentxwQne=+a}X|2{upNo1#&=7ndBoN1KKuEZ&(C z>)>}iLo9_pYSa@2ds$HQ#hI9|fzpQ>Jc)ik{Pt{3(rXUKd%JpS+ z?vm~R*~KcGRoz?TVBvyzi$rdJ^+;GNnyjnnAl)*0W1_*Jkvdl#cvEC4kg;yICdcwb zMRD_snRMExO-$pP0s6r~i;kk5N2Zmx`jopi_JPTOZOk4V{cY~)sU5od3XlU(1whv^ z&X-bv&(>9zWoR%D$zd}HPa1%)uRjm2TdXoR+la2-U}=J$)^Kb3U|EU)$%x{0a-WaRp-ZZ4!(Qn{^t|B%eUnWt{w2W@HY!uBvTDb1V+9 z>J%F3P(i`^d7I^5$8pvQ^j{?BzmZJS0HxSaG6=&E!~-)M1rVP>e#O`l_%*!$4P@3~ z!Gnx&Oq`Vhr{}a4DYD-LNC#;bwR%RCYqZ(tu~eGdXQ4&~8|OpOd_sq7-ulxV)yF{j z(SdZW_6PUa6=hX$)_Kt%Yc*$nB}jFCc|Gcreun}~_ectVVBaHa32hT0TR3_|yZJZG zWypqehiF??(+tZ4AB|>LmmA=*d;L#u;GrPUSU#6;^<{I`?Rz3tNaMw%OvqH)=w{( zVm}l@m#_gQ(-P$BS~;mi|6JDXj5UPCy(cr$Bp_PNa8FW<{b1+3n6)eew9Qk24i_+4 z;T3u%Gln5^yEMzY03a`DqD97mCsjI77JFxd@$hIkPw*g;`5ErsEs4%t7IzPq{u?qB zecl))%{|@ixUMYBscs-K?Q^)@t6f7<`6;N+nJac4*ee@TW?YWbF7e^g2y)Dqb&8!D z!t56MBx(GR&@pg35TR!Oag_`8XIlQI?Zi0r?-)kTM8U6WGQYm}_;tS>KlT$no%b0y z;g_Ome_)P*(Hn;I*VGIC$kTM15=Zncg>!%%{z5RbT4oJu;ez14VTY4WMMFdc8jxQm1@f0{MW*#_}U08rbaUr zT%+L{=ed4Q8J`@b8GCM1Yk~kX(fn5OJ-D>?PI=1 zi8cSPf^wrO+%&z@-TJE7+KUt9r#%bM`N-58J~nEy6=l4CHf|l+oWya` zZ~mjgS+oCPp({jEDalbFj2`Pf{N+_+2T6pCr|(X<#d6j)Mg6nqd(VW4T(qwgwmmFL z`xWaa#piJzUC_&VABPC|8waGbCxhMIr)a%DpzP6LMGqLcHub1VYfDql9%w?qPA@*B zJ0*dUl>RnOZg|S8uXBk1Z-puxFTw#3r{I zb_fCXxM-stTfHXB1kK}Ul9sE542KRIu*1cw&rzyVgFr{0} z*beUB#tI(~4uA_b!-w!$ja)Jp10}Do|JN^#)I_0#5o*^Bk3a6x_%jq06N3|O&%q6RAtJknTDX;|2iLqkUF?ptS;e{aI_ z>!DYmJ#N?W;9+ea{Ep#zRfRcCEfpdl9y5X6C_cI%|mOQ<7P=sz7mD{VBo8Rbleq`mMXopxxb2A!{NvDUT zB&JFiQ#C$bmdXd^Z$iPRp!{u_)A%+{XV@dBaPd%1e=)TD%;tK|T z+~R7#o~dgwaN7Ue&-F*&uS_W3lKtPf+|ianbyy~h?}yeg3w>Pm)6jrO+P!7(qPrP> zFQ>sbAj$n}xn<>A(QkCWR`aa@(<=QS^9{RU>nqhQgCv~P0{lC6&<~unQe+Fwe79Er zvjB)2eao3|bedP;h7r$)j)f>}L~?}dcM!h5e3LMWeeb>^m1HFd;@QX1g|85n$i^u` zSGuQ_$r&P&7JTBiIMmZ%{(k@mTJ=q-5W4^n`rQ7|VbMmKPa{m@7G;B&?FmGb!1Zu} z^XlqmD5IdT5BoII5O9B^`FUL$CA=()FR=jcY)Fkl~$R|uy27( z=^876#oOv=&eLMZ)egv=-Sy4k^!#|5HJgY>{IHsKo%Ax9bLxo4?1eNGm_^+3;tumD zhFwHtH(#Mb0gf|3s`&IyQ^t2H{PUUzYLoYjR~B=ZnIpJ9yw-7}%Rm?8;hl$EzE27k zi6u@_OOw-fju5@K^-FkeKsFgfwQYCKzxJEH?FTn5CUT?E!BdR_v>7{#@A`5mP1lD1 z)?Q}dXJ{C?rzXGR;Kb+XnG3t;J-_VGZj<7oc?_9j z`^GMJ7_;elQrlj*tXA7TT2aIxRU(X6X;G4vpFHvPnNGlZ<=6*EV-pBZzkLmX_y1_; z@$K?;?F0QPou1gEIC$?7bDvPZ z{>2CIhNhhfhLxF%zIv2H)<{WAdf$dC&y5W9Twvk81=20Ct=D*U;g#7pANt@cYbY4Y z(1|!k^kA2ebg+??n9b;miln55PQX?JCu2&)zU!(a#Jkh7?{YlQ6PGR$Q@ zbPY}KaR0jK%wA;moo)lnkT9z{?=0}24!iIhZmP!5m(@u#6ue23{Rti*#07;C+k#z3 zt$RR>k)L#ximga-MTYXDTo3t(FzQthr*zzQ75{YE11f{Gih*b2AbId6e!0Z# zkfat}P0Wg4LR&<`+hJ9=K0Anb`!C^5UvfPPpZ_7en_SPJ(R+&2F@W`Y%;x<&Roqy8 z_>v=e!N>iV=q)u5Kt_-L;C?op?I2u4TtE=3-|J?aI`nSv3OG}(ntK6C#{#_{Tb&r1Li_N0l*$=sUA;v}@2POJ`Z^+;lpgi4txmvuL9s0lzBOnY6A^@y%Td;!}^$ zBG>QwKkoqgnu?9Nd8Sn_7#zSI@@M}Kq3YluOmfipts$*0%wV#c1-eI;l#7s+D4ibZ zVx}F3u!)yj%sZQ#n|P`|Yg_{v90(wXJ|J#LrsmJ{VR~8Z1>>9NEn-F z6)saFP1^?aYuuLotIqaTXoZ5Ah3DJbVSdez>Hm)#?Aj0rar<#5GrAbQ3XyKbxAtP+ z++BmTt^OhljAom24@M2YxCA#yf_vSBe-NKvl((o-u&lgN`5c#tkYH~ZR6m#!PtQ3mMCfNO0 zjmu;Apoj69HQELmSdHD++?;_u{@K=uG_TYO93n(3BbAX;z7EmAZp%MlckPLxaSxrL zIS@dSBXP;#jH>xFo2x>IPJVMGVirmy*FAKwR{k*lFyl_P;D>51yxm#5)`TF{Gz}6N zcg1*?=GShAWMazQC*}9d^U`4G3n&G=vn=E0oXw=-vma4IXyh=qWm(TrZblrVCt_Ea zc#GK39NPHmNsT740ES>64)WXw-j9&e*uA{GxlL)qYY@d?SV>>3aV%-FDO=?l6|V(5 zTCFM!LUY7~8g@%>uAi`C#`Kw+zR=^ct%uf5Gl4Co^Sr*oxwTg{MY=s}e6$qa?}{r+ zGWO(W_D7t4SR15Hw#2NzCnVkFj0iPQt$Gahts+IhfvO(Ia_bhR;sTx^B-7P*p~DUn|*+`f5{(ci$L;y?5}a)d$4)u1G7HR%?x#x zyHI?IgvYKDmV1S60brcMYxnGe;k%5!Oq~`%Y!*otM|PW)*s9V!g1cENmP^tT8IP7p z?bJ_YX8*(*U6%7($M7})^zMuiDuLUVacEqU_XqXW!Mp*HE*|VyPc-C;c z6tKUKIS*v_Y+m>=7VkVy1xULpV7J*Q=Di-2`#&Hjd9m~9z-+$eL!Y%tN@>I_V{5(7l!yc)Me&Y~-^q`oVU02LOFU?!a zlfDi2K}9myhY(U6Xks4nGP7tabcO}QtoN)^8PdtJDp`2Q(o?XqHc;@V%x7Af(j+Z$ zTXI+;GiV-ic;jc4PUvB#(}@Q1VcgZkv7o!2D7I&AtvAbheJi% z@q1lN(ce)JW|;zrFj7r)OH(1r+33q%RyL0X#fFO3QEgJ9QfzS(!d%c}NSXSz*?Gnu zVvj}P6xha`*BctF38hMlzS=HkrDWHU%;3bBF#Db-Z9etM;TwZ~DdI60eDrq=5)F{^ zN)#N-!m6K~+WX6i4IIH~xJcf|LMiKSxmcj>IKh*i6-O)h4c~|tTT4-M5F0xMG4mZ} z%TDLaOh*8*{xn~>Oz%)U|4o-OZkjt2;K%B)Nyg5Yds2r$CE{mZO#Ft z=Ok#YPoeG5kgq_ojLsj!FqoOVkohzCM&cL~VS&Aa!FH#MIz^{CY8 zp8}$l=OY?+`8A|BX9(H<7T*IbQWp{&&nTXskxY=#0t_abDxd!DpAq%wUo4r757Q5Z z4?*{^uuQs{* z8mrbrgQ5R`aUJpN&BYesk=pSCde0!TQ5_rT<;Vj@Ex=;_kM$L3NK^}sbyGbR9s&QB z43fu1OcXmtmPPoc8eo6!gu?))&{2Wu@t8Jd3zCt*!^2b9pWXM-1f+j9PZkGi3#|me z38^RTWSzr)O^KId8c%(sGc`agzV1ZwYOh<3L3_3s*JA3K&itUS%&o)Czgw-HUjXC4 z%Gan2I=2EPKGyVLy;zeiJSs^>4c$pbF*`!XQ(m*azSrL2zxsE!8fTwDKYeD)kM~{8 z#^W89c-{@N*L$mvZx|QdRE7~3{3&s4mwG609NhDQALB-DtllkT5Nh#tuMSMNaF6if z2%~l!5&FDC=1v(T8M(6skIW>_&|FXGHh+496{a>6sp(#U6mt8ULxlyLq4 z6BpOGV)#@bO7sNpAqAC*2GI(zF&wC>?Mm=ii6~$qG#`OENv#?#XvsgjjsI8Xfb3KY z(rs3tZZ*Qh@TQnX;2z=e&CtlN`mx{l*rCOo%$|nU1UeUruS}v6dU}5i9wH}7IF_MIWHHh#rYEFzGd%)I zCYd4ck%I6cxB9Mpi)OYcP64aoUGg|Tom}k|7TSV_2D~wiZ3vsR8W5iB8490g24;;H z?T4uT{<+M4x0PFkVy0Z+1u}p`VyOi5!#@#7ge?3RKOTJI(u&TucmTSMR@#`yVCQLa z+6a{^s8QC>Lt8e^V~P~gK0Gw*6%c*3=Bs#er%k_~TMi9FgUD12#Q8=`kAfV_Lf2`v z$yfqGGaH@D38$yGi&O=ee7QvGF^_>Pyuv6xIPR1skXU85d$e~vgoa{Hm+-6CfN$XE z^8PR`R}=walH3&+aR650al>rKE3DBFuuAQ635t+E9oWOow0`1j2C{I?%xeth7Z8$y zyjp&}*GQN|-qUUI^zEIe_qRpjw6klEIg*>D_mEzDx;c0~!v*rQ4OQe5cZQ%1+T7(I z;**ChKZgEs^B0?ZdAVZT5F2Yzfp3QFj3!S9+Bi|pap{M-aOy*UlHE<_3? z?M2!_4~`0-n~`S$XT~V>cXF0EC#Ao}pERzV1vypb=D5$RH`~SCc9`GzUF{DeDjf{S zKZxJ^8E*L|+QDJzf(YEy2&^XOXB$l@P?FLGtkdcUC9~7NN)-3-*G1iRn?mpyW4g2m z|H`4)hXFC38P1LKiq4oP?6>X_VjABiT3kS467k~i`z@j`x8Q;C@q?t(z4^bMUBlST zn(n)sD#;1rvLo#D_Qb(U{G1|3!n}{4;nN7vfTfM$;Mu23>31O>i#g_{dw~2v_`cP= z$@)7C7C}y0>==9Lu?E_mMahp9^SmT($D4uS@(h66oEoNI7y%G9H3<(4b1qla1bV6h z2HC7ly)>s}o?^2P%-R|FCm%hG@anPKyNG&a^7qETix9Kyxpo=ZM+#p7?%ov}O?*f_PE5a|6(QP1Iw2u$_Qjd!1>|IGsowPK z;B)HvWT~I>l_)Z;Q3Hbgaei+mFHto7_Y!3+@D@t8WD*whitN|tH0fI(_Ib^IOQ!A^ z5Y>0~H}%{;$H4ECKSNp-T&fi?;QLp{bs9lv5x(Dd z8h!~cmZbN-WI0#}q$#+%RlkX;tU~H5ttt*k$3l9?}ARZSSCE zoCo61@IL$vr-d6|wT3)5x8&zt(e z1j7I@vLb`;eFdJ`>fSjuv@?X2yEU#I!N;$bOtOH$@>}T5EYz?()~Om}MgQEtcnvHC zL;#h;_CF!@wq8qK>4CiUi$lN1o;DG)hV`d<7T@0^tHx_STiJv7Vv$cT*vE)6GK*ev>0-KYuFNLB=42`G3Q8@RA>K#h)xybu6Vwf9W3b7E zQc7ktcO1_thr1_+w`ACU9Fh!L-xFc#Nmpd|zl899)u;;~@tvZEIoPXa+6@2TiX+27 zF7&~%3E`VsEHMjzD$w@g&Uh_$*SXwV|AvdvHpl225z7plm~6TfU|g5A5K|MtzI5$- zTb+Uaw2_6jbJS}~mfKEUC-9P#ruhWs1g*vun@L+|TX-7s^6py} ztds4wocYBP4OHk4!|t6gS&n#4tcV@7lVk>4tSnZBZ|v(_`7iS<q-Zr?!TckvK3;F((6))y|a&p<4BV?alRNYoMPZ=w!Z?=eP0@k(f-)%4p?}lF>Pi^^TutJV@{R z4IcEk(0K(Fr0~8b%+ek|>v|fD_Se+W|B0K)x`^{?_VaTFw`@T(#McvQ|1sy#Hs@}i zoBRh4U#}hboW5%c16k)LkagC110b+N5GBfGDwO`$qT$`gB<_ECshNL*cd5gkRwQ4( z*{G*MeQ3H!VOihywRwCeFCp=d$?xmS2NA{Gx}&kWu1B`w7tfy(g!tJoovMoToYl}u zDZd+nxBi%zOU2>6*UUrO#KqFW2WA*ZhpZ@U&A>QmnAS{PsT1#HNnnd|_9hU+oC7+U z{Fz6qjrn5p_#=H)#j8Pk0sR2meV*@s_^cC>n!4t@pZ~qJ`ZkcjRYDmjWq7kIOPC6vNu|{l?Fzh@RDZL}zQ+Q2$$!TwBGB2I zoV|23qPJea1nYYSr2OK{fF@ILOzRVjeRjAFf53p)@Y)LqiKJ?=c2b-3)WOFXj z<$FYLR5JZ!Q?c$?kT36XHxQtHiG*O(Bpli&F^(5z=X6Gevk@ql;<`1HY#`3;{0aWY z3$`ohtM%vTnUnl0ARP5$%Z?lv&#K{-+!bsFwg@kdr9ZG9vGs@3JEFH(yN1CH>Q$2f zP<)VO{aNTqhkcVv25|it*Bv&rJD0u}`cgF7CN^{Ajq^2m|LmH)PxdriW9D~Tx&qW% zWv*sUndc(~!G&AWzhu`y7 zoI3r_yX7_O#*Z=wZW4VX9qTbo(}-A&IN(rfOWVIcdx%>n@_Wum|E=NkG#QU%JibA7R4wdm7&nfJ!Ub;iOeqff{-gt76Q zhCw(Jj=xOT`k~k7Vi$6;`8$XcrMazebM!p%ZowjVc zje+(dZ7ox*680c>d9khp;P4H`z^CN_CP<*kci9baOa_4JjCZlh12~_$8R^ zKQn$1^nz5@TgO4PS%|!)axUTaXP#Tm-t>AAZym7LaqTBM801^pRf&CYL|VkKR%oN+ z>PPhwi{N<3uc9u&hSpqI>#V%x_ylmFbTEB*yPnu4(Vrcgr0XhK82H;i>Vvfj+&3Mi zJBwI5zWoe#1rbYrV*4z!V;#d1=q%PIGjGDHW?9G;J7Y>Q5!E}CQR#w*-@bO%7$i_& zaM1IC=v&Z}H+V$IRwVq*rMGb-s+b_%B{Bzpkv2|S2w(B?=3u^cckh@4nKV0L)E0OfahXICksdxF2d_U#RxPNumJV9gwKx z{gmasU}-grwN4I^diKBnX-U(`uN*;FVCA7ohEI}byfmrCZCjUpMG<=WGg~lCBnj;9 z^*P5Dn%Uob8-06!sgSyPlyzK2J-jDsYz)e_7S}%9)f6{V@gyzBz6Z(Z`MyA!L8v>E zDScea9gg~C*V@Cb#?Y!L7Hp(Wc!B@^X5mD&U(ABDR1t8TTH#oI!h6{rAlSk!1o@Q( zhUhk+VqNybFCH7)=_r2;b&vXIw8U|s`4>w9B8A&ehIDEe|L6MV4dnQEl{tHJr9WksHbT0YA8PS~8`h)o!@D_}O9-jeBDxkKpw9R)rU;5!O7Pgy) zdUC3d07PRk;0}$FFMdx~?B=I=XEk~n@R`>brC6eb`vR(82m@ll{5W%f^yeVX@Q# z){l(epyQL}f|$wsNtieofm^&0EqBL245Nmv6H|dj-|k0@^gr%;RPrYtCjYAc>`zQb%#NCC=zihX&UZ3v;>S7#i1@3jH$-UO`&-xm(vd?V)T-`oQr@ywgs`)T{N=m zgOjKE*@g;Lyk}@<$Ba2pFA9B=RP!x8Devb~i~kuPTsRtGeZ3YltLl}H8QXXDl%Clh z=m&H*p$?OD?4aWA1maVxt$UDJ*+6CftNHUKF;@?R{=;rH!p`e3I0AFN)TW2tlE*h8 z*bSY|bN1Q%Vjv~;@2{+X>(B|C?S*AD#jCshbp-_G!|{9{eP#>|)3h>sCwOC5&GX*w zW8;BbBW*C;bBH%^C+nuuL^+Cj5->-p9siZ1IT(F!isBpceIWuW*c_pnmTARV zpXiq(A4GZPct=-v>lj^1-|I^DVfa=kCT#s}6QH9`+a9QMJ+*1$zbE-N<`$#Uk!1U) z-?u)?cYw!4(wHSP@)et$~WJcT<$$8a*uut zp~$*s#o1a)d#&aMX#r>6<8LvaDGvW3$TO}9@;@6F#ULwL?tz>G4t;-{0Pi$FM!p?O z;bgdR?C2Z!a+PJ*NN(^)4Ts(0^qsM^Ix@SUVH7`KRP+^cjbl|At}DbvRuEdxvj*9S zAR*~v=0~Ph6a-Gya(UYMs>8)K-W-X*_6#%r9oN(Aac%C$PW#WQE4;Cuqk)3h``#zG zBN=*6=5&irXpXD$<VLufPE`{g&=$`;#D6Io1kuf0x0lUp&tkIt3Tj3<&g0_ zx{9>5`rZryBz9Ju=o7eec`3M}!Z6 zNV_+S_V;zcB~6Ui@(&Dz@)T{{Ivde!&p}XPeQnSm0ht>B`ddOzhj(LvXB^aXs`BzE)kZJ3H$X=T<uIk=;~!;u+a*#j#6^4BJP3J`-;@BhL${`miV zwdyCfb+jVpZBz(3e=(~6=QYe`q;8HHbz$XW8Eao(N-V1Bph z76m`o^Nfs68y)5Uu=lnpt`(}w;~V;Kx^0Qx)$wSB()ZdSf6lXev9YV&!mWIa`|2RX z>TddLH`o(zI)|O`>^Iwc4dC(1In3U9hHg>&#SjPX!MLDOu${iNwHYXZuTwzC)&nD; z=vWcj0Rr1$Ww6mG@9`L9nY)5V#JrFCUik92KtHNy)Z-_2?tZ3D!&1q;wEdY{lE}SB z$I>5Ki@*@;irkEmnY=5JV$Kj#{Oo}b>G~gvRA37g)_XR{ZprpLjr^kZY%7eF^1(DB zzPo3J^w;zp+2nmAkZ zN7SQ+dt>HY{3{?-w#0$Gm&opXO(%&&8E!)LHFqkOb*~<#m~F7nX=5eOjPF(=7s&X1 zA7!i#cRCn(zFmENCHDZ@jaPGI`mB;;I_RtEceSHnzJ|#_NAwjD$VI8Pb)Nx5o6FEL zS1(&)b@^@RECy~h1@^|H*un*WNKd-n*O@BYyCEv-zTWl zuL7qt5YCPxpv3}M>ME}l<@3`y&5qup{f4D24RkI`e~ZP!L{E0cftbQ&+{G@NbXs6X zW$M%tRN%Ls;KRh;F|fPZ0lJIu-_k)p{e7sKCS2uWZ}iA>dbof+hpW2*1eiQ!w+VL9 zgYO~X(WGyC!Fb|}D9oNak5Hv|+F9d~xH0qL)GdhI1?0 zG`npTKCRtFE-mt=`{%(c0Byx4kyZIt_srrQ{@G0ipQ64u+TG8=P6V8;n~bg+x?-6$ z>^9kzr4FD6Kah8+W3lX1kGq~@SHc$7b?ey=lF1+?7XbkY9^ZKTR_kJsdor*1f@A4a zPpP^%e+Jsx=DGJcwRG9mKYOeP`s!Gh+cT_0lB3uF8`FoeP-bZ{KO#BsV__0g*S=7SAvBDVII&|m>O~I0=J8SL zb67U=Mv_5!msfn?S_&|ql_+P5~0&0xfILc3X{AoWrIElDXn#w70Z2!ll2PT zK4@jvXnN_&^BM_>CSPGu+kDu)wEGh*R71a)kfQh{K>uN;iYxmVenFjMyWHrj`UqWw z5EhpqkKV(2^Lm2LU$ws-i||Jw!u<-b2cpVaM1soS9)t#ZhV&mjCo4Q(g6cL=aR^JT ze_t*9Ro>B!6vL}0iDYFnNyVfF8ZYOcozvaLCUx8ri|`N=or7N-}Ldby&m zMtSFGgY-Cf@>2u2UZQrLCmp>fBVq2(jEGs_0!})eT;RX=mH8N z$>HS-cX}RxJqG^X-~64RAOBH$VGQZo)+#um~aNeCc;v(A4P+PyqIo&4D_DW8s(JqK`Jl#<@@7Y;B)rDHL1S z4B(A~OL6tlQ8)4Cc<{t*Xn<`GBJ%#&577-tRwzz{ePe$0rNd?M8Jp6^%AZh_HBG#V z1?bBQV_?5@mGS3m-0|`wii5dzxiaSNMoF|be9GTcdi|@)x-5J(*JTGroS0IV;2Mg# zQ1$c+(`EW8D>U*apSP5aY$)&;%)gnkv~}%UY2@@3UE&Lp8Ah3e9j3=q9i@$?R$5FT z^r=kcR*xyhs4g!$Kc0f6-mlHa*0pJO8mDmRtP3iW!F&Ylm`BKc`J4RWnToBhUV3Ei zKht_BKIu)573_KALlYV@lj zLlpe%ABOOU~-4%W>qhO~rf{mA&PcS7Nw;d;D{UNL4 z#L1*GAIeNLRdZ;jE>LT6sw*872IVUhU_-c<G7WbecF2|2-dX)l6eFk6+;sD z?>E-sj=-*<;x|wTu*a;nOO!FcDno>;hnV;W2fo>*UlD2viQ)j5ad&upo9W#QLs$xg z>e#qe-A^$!B%mpIXX1~kHGkNPSm`8Rt(cpi%_^~hNw_h_$R#{6X6aZOdeS)c3B8mE z<2|#+-n}?xGkajT?d1A!w|U{#88ETzc~+(6N#tP)Hndh>U-YMT6<^g*<|;0$N2SqZ ziw5;DXNn}a#sCLr*R_8eZCR>l_$u7?cvJD1h1i;1L!*K6_}~oscBO6&zz3i7ZCK?y ze$ZcFkOA`urrTtWwyQWbj+t;olOp$DEb3*k=ZlP|Etc7p-O zI0v00nDWMU>3Yd7O1xo*UuJ9xaiklZcsTh5Usk5@h)M~!OD>bcdamwxsLImx&Y}DD zxK`q9=JtL;E*|9Oa4pEB`|7ip_R7j$bqHcP2{(IR83Er9;3rPo9xu<1X=H5Hgh$s@C_uZQiFbGjXX$+7KX@Q|ZIt6LzZV(h15CLfcrD13!q(gE5>F!iIq+^JIiG4Po zZ~V@4p4WMvKbhCeu=d((?^*l4uj_reIcUkG-Te3-9mbIUWE5805Q1gZ$n@F>)P@xH z2}!&_ttY^#^~b@Vse5lfVBeD{!TZIVnIcmTFU`aT?{qGe?mUbOdMrUUIhp1sI}6(Y z*wzWoE(Dp*jLhp+%VMFauKPetERZ|0Ccd1GfeaJY0NC?GIHgVg+9N*hUyxm_+54wo zT3E!ej0-?Q?9~T%c6~gijqi8mUT2$4+}MKzT!c-=?)2j{PfC&Y%U#u7{2ELi{Vil~d=75qZ zaP28(Ei7%&g$M#~Vz<(PrB3gx)6E+0tpU9QutB}=0UB0C)#}50!$gRXdXIk`*Rvf2 zUvJGvw9aXGhi5l{iyq+5#6%2G-x~fNm#WmV+w2jCWNFmdBgwRfD4t73KeMANjdPZA z{Cq6fQ{G~P`JWV})}SE@EF{~jSU%sc^egZp6x7E7MArYw%e8?f4|o#bH2%f__yIYh zn=+1SdVPdjn-U8Tqh#x{|IKw*&VZ6*oGj;ggAQ&+^Vc*`ZQl1D%So*YP&#(k%2u(z zCe#ysQ~>GgHK(YLeddWZkH0K3(Zo&ft?e3ykKpc{Dv0hQ0rZmL2mdsjFi~|IZhDklz zEk7Rc*BWe+1%%&Gy*s^-M5kTx-TT`-lypR#$nFxDx?1uEsfvH0cZ45$$x3_9Y4M+V0js4e z`Se>S5N!9&&*?y>p4YHyjIgmvui2Vw)~BuVi6R(vN;40h;O=*|#F?Fnn`l<}l~osD z!-x|@EHph_IS-G^1?Oh;sDH7|&)?+ntTnWF7d!S$?UXoO8B&i>4wlUuh`MIc7cVX% zH8^&SpALSYKQ9!WkWR#=GwN>v)U}Wi{NV)vrQim%vlUYHc)0>22>fm!YAD4Py(Q0R zC_T)K`x&rLeB_x7ZSw@a2{%K~2>=s8S?FhSuOv3n3y1;RQRFluIu`D@8%tY2xW}MQ z3FUSG8pu`P7x=*@7Utj1WJ8mxT7SN}3L3^2xhp5<@h>ub%PMr9ljM(@>z%@k_x^9A zJL}&`onC6lGO7;%8e2eN9o&WAj#ENebl4j$+L#2k5Dbsc7Y?%=M=3mgrbm3($lES^ z3ZX#X2}G@luCii8-6v`DA4q`V2N{yJ#jPF;C}rq@ye?S`u}MO;mkyV3X3N)yPCO%5M(cfskhBqc>HUeJ?Gn(RVb z`Gnu^aRtZXyT}E3iK2k*sk!QD!!kF4+8n%Lo5s(N-zw2<#qSJ7ek3#?h}RyVj4>qG zpdEUVrdQFw@}%tN#NK<5L0@W@t5P+<(G(RnH`^ZKIi-O$S3&yIB~3{!d;Mmj}O zs5zB|Dh;fiP@cYAdG8w^lx1jX&7SHcGx}^nLqPZxw1W(u?<9tVr>R*NX>%J3t;$(; zJ&19!l1h6g-BNt10c=3(gZHI5CKOdvcphW>nW_+H+fd{e_@m!3gL-p7V-IwDT=2XHIxxU zQ`TYUQqh&p_v{gtCI`Ub0R^wnaK`lMSx&noOQ2}73i8lI|jp7>5e_}K_P*etiG(XapFJg;i|qT82(`*|m_O3JVrUbO$S zi25rS?J|Nt`^rm6axwLpc^5P}JE|y3yFbl6-A?!ex@Sy5e+-LS2MP}WF#hHZEs!0e zknbv2wPZXDs)AtRE73MDa;N9S>c^Vgij_5-Wp#|QA{f@t|{(cI==ghEX zp{C1h-9VZAUDf!ek((YWAPZV{7KRQb$$rFvvvoAmSUw@@yUw# z+E{9I`_T>4;E~D%JFB?^O&a;N%h|NE-6Dc>E{@wbsIDOXVE(A}Eq8+_>?g6&iaFu| zb78%Qz`gR}#lO@>lYG!OIo}swQ6*;~CeI6V1OXPK5zDiW=ZEF0Cr7op#-Eh6-84TF z?NA)g+>w+%cXBz^D*#{`@}sUDxOg7 zF_QWhRy{BhDrC04wBg7|wuO*u?3hwDob zYij$SQ@KA97>X$N43Ml&2{`LK?4gP`xhHo}Ng?EPQ{?Y({G52+&>B=3RnM9#o53$i zN|fTvc8z*hMkf&=9_b|ieoaxe@XWLTW4)6PlO_M<_Iw{G9>)Kz6lz-Ni*2Xz79mwM@Lw*MCD7G$p!ob)?+Ue-u;Pyg21t5iuz6Le;w=Au4<}{sr zZdFxlGXY#Cz=M&nyho%QSjYK4XUA{--9Fg|WRkj*p@B&Zbk_)-J$81zJ#dyB3iXP^ zKx7$Q1u2@dGoF$>@BK4E%=DoYOpQsa!naV+hDFijS z*X5@@;+6URR{vNM-Z88EjYnc-hdUAF%@c2PoG|!|Y6>qp(>E#L_1g+cRWEiFyx+CD zZ{ROO&4;`PD%|X?z6hpFJHijSu-u_LsYiSb4|&AKpnbP#)Nk`n_?;>3yEqJTOR6vl zFGw*zX&kgv^Urx*jx2Dx``f`SJLdT77YfNSG+d^jT35^ZUft#-WApn#bJ1@YN7}@I zn1$`VrPhyk4?Mpe3ri%n#BuQFLW`l^lOQ7A!vy7u|60DIyOBGkUi_^SjTaCKQleU|q)_#&u@nV!vVWd3t=9rMp(O|4{n2_I=D zmApIxxMQH_PG@HLzX$n90MBTk9;7QQc9^&z(mYpr%7LWYY99{1s)g3vF$Vh1!eE*R z^&>QLgz8S zv#C&Pq`Yml_)$|L(Y}RK7enUe`AA)_ul=ixHm&=2hQE3D20BG^SjF$evi*n%EUwWJ zaktgUBiu|Go&iIVE+5;L>kylF5yXGCB{Yopt~blT&1UWrVmKrqy6Z$wQCRjns)$s}K z#_4|j(axlj;u^&F8Os9H2_RG7zKA@?UA+sGkUQ~8j2T}+?En}Es|GffYU@goW})YV zNX9?*Zi1JLmx~*$iu+#=W7fl~nK{QYs zp>K zz1~|6a+{O0|uyt=UMi_xvnre?#;$`;c?PE2F;I|~#% zl=b1xkoD5Z+0XHFXQu26GpwX(T10xn`5V<3cl1hy1B}7cM^#TC=?MutGknxgUi7*3 z?Yl-uh&(QbJ0BV6Z4G|(Eij+Ni&qyDe~I5CP+N8m=PMKZTEu&Lnr{pGi!L~4sa1{U3u zYy*I68ZhHNthK*pA2sk?sG`>D*Yb1XIgJ0K6?+keW8( za``%==Gn0zRtKd0Mj)9sH*mW3PP%0V4RA@mjf;0)g@qE#Z1uQK%bxrW5hT z8bAZgvHy|E@OX~_!2@)V+*oi9bN@Am8CaQr&*5X=?|pa^PeHNn(&mumg{`G=W@TT- zanQ!XF3=)e3+ZlE0+u?|LU+NAI^0EI3$69`YETavGp+z>ae{+tt+!Jg=MC`I=M>HNlT~acV9l|L@hSXZj9^ zCDig))-lz1rG_7=ZYQmPZ$vBqo5A5dZE1oz&7qXC!a6Oz)2isz!Y==_Oyy_g`5^Gy zM&$n&jLz`Cfzg#uAy-7OVCb8*XMlOI-Al8B?AQ&NjynoV*bmM8w@#ZM$eF%EbmjSb z6ObblCg!(0?>Cno2ZF%)4Hgq~ytvYPpQ4H=@heF0;@myMbrDzq@Uz8SYJZX6RWNlJ|pH zax+6Xe9UPkhnhbz6OBG%C>Z)LMVwo;2VbvE@V~Tu z_0*Bvf04?+f~4|AC5(9cD3yIRko+RJYL%x^ODXe?+$j?BR(H?pwCO8hm3?#XX$*_! z5^YGl&|FT`{JK5d>RU~gcjAv2+=)9Ni~Y?tpqz{CE=Zf-SH9zwbz9{6SpG$8Xm z&pZCX(f{WS5d)`FoA;I-jwC(<0%_BMa{~4yB$F^TQBryID z-JNJB?^1l8v-Im75v93hqMdI$&`*r%^P%DghX7?fxhl|QgjA^Bqer}S5BLpm{KbQr z45ka7gRY|XuLzy4?@x@|h6lSC(-oe7p@cU%PT!t_H{f2)r?ZI2lHPc?KDB;dE(_RoL%afb_-eM&2AU4Bayb$Y?kX=_uqL7(L zR2db{7xbVS>}9wVlcm>wNmqe3C09GPjUCz7N~j#XDv!cXk8i|)1p^*l`H!^y_x|`+{*F^o-B@0lqwsA8;Y{)*y zu;*foY0t73?hEkuI`$hza!@i;kaZ1OAtk3q?mS9)Jdd;J^JB5vjy?1laa-I}{ z{$tp}y|0}fAqlN8)~#`<-g(keUhcZNGa)No2#U-}QbajT;BrY-L!b62yjcOWcHemb zc!jRl8AfObr%K;DYr`(JVsMu10(NDsv{X6xH(K^8PY!hNzG$UCZ528g$#MNd%s*?@WQ(GzXlQk=-UI$y?J~q zcb(!ttd{Kq+Y=nvnRZjeA;od*7LNVPZsp;P-_W=Il`jgZ;~xorJZ1wsFux8x4G%8C zaeO#oYaJ<)g0CLxb(_sEvbC%^>|Zw}Ssmb{UJ~acW41TIp1;c;kkF+um06Z^0>ZG7RS15?GkJwihx?95_ zEBr@ki)NRq?#WHP+c;*rP&4CEftu)l#9#7JY>}RfZGxY^kEINr_ z?#M;UrDW6nfNVUGu1hHBbVBUWu;n5-nW=xCY7nw_`v;(QS%RO;-XCY=ckLjOW5e+u zLoQgELRXV7ZUX+*}Khl|aus&`Vl+V~cR=pJq zdHr?>zMBT_GWL|V)l;^RQ30>MXav?Y9xHkf zyS|p;zDo-GPIsPoaXbR{?lgC3V$S!?Iduy4@Xebtd;pD0SBM{~0|XpG7C@PxEvy`n zT{6cl<)*9+(r^Zf+jhamtusGZki6W~qF&2;N_H!%^GT`*X#D@f08m-vg&Rn%FNP`#9ga&qpBNgO?Jd zwu`SCnlE!CycISD@%N_-q(re@e+iy6MHbeADb&y2{q*{IQ|ZNe!2{}KP}nv3vo@V% z2TK$X4d<3>FkM*I1UKLwk zYIN)?k@)ey=4?zHc@j+_tbFD_Um_r2h+Oa7d8UmjPoZO|j;))s-&T4)fpyrM$W#z{ zuZ;Oc^Mx?0IJYmCGZC+9Z`FQnq>c>)^e17{-hgeU%O6L<2TJFrbYQx{m+0e()Q=C! z^9BX4W-qE{7{7+o94b=-2zi!iR@#JV;vHxNBfmR_&rtEi|7x4H+bTqcv3=Ex;7M#G zxYt)fZzXR(5$KMwW)*ASW9EkOV;RP$sS>R0B1slX>?dDW6~)Jga#mXtNZuWGV- zk-E2G!NxSe%?-fSuuGv=>Bko()!Qm`W}ATp7^wMKuug*(QV{`<0;0|o#0n4d0)(Dr zq>I*uFLh)-`pc1+z_V^UY#{-F$T}Td`_0|lwVfQLutg`iZ;AvotD^nW!HVj>;u`65r`^G1Q^{Je+F|*{DG7170D<(9`+JQnyi} z{w!)YupNE&PdmEaE8vQM;sm;|0+JE0@Z$e;fl@2SrB%>KHI{FP{&4~A2uPv?idx}Q zct1o~u?aweS(i5xm5qf?%2m;bu6RTv=l`-V z@o&0B?*w_u@`p$B;=8^0z(Ay5-(naVNJ(0T1H7FTcdK9eIZN;F zhOC`^Y&?YxV`C+O2B8PUw@;NB(w5q0o%wN5Bdyr8>afm@T#Jxz-aiBL(s}%kBNHdM ziQ^u!b;Bi!3Ovdc*|>0>u2#m^bFgqE{MZZ6o`PCj4^G8DI!pCO#0Bp)E;L?#UGuv! z(MlPQ0h0`g^sBbuGsSNz(1%gKggCwqRKaB%#Eb1{+yCL&vw=MOj>jj3>MsfN1M>we z*s=@$dHpH)I(He+j=xy+0%DSg8JTg4$!Ba$_@$EYHA|=M*XE6hflj!q{~GNmOpBq4 zX=Gn|J=9$5BeqN5w36R=)cr*qYwal5u@vGO*Wi(LR!EbA8Uih|#AP%d`z*+x+P`G_2;GhM&-%xzr4K5Qb7`N4J)kU1 zb-MP@Gz`Ny31&89oQUqDo;;9;-!^jMsl}RvVsaZC5Po6#OJEJ|3E*B77~PE9=H&!> zobz;UjFx8;kL($Mt#z{88PwQSE#KpwS(Wa6Q^&*L8LhGTH$ioSYpN3xt5^vk)& zHJ^Vp+;W&=_&6Q~5dB;U?M?6CdUyD9ByM)FCv~rs2km=O9BhUAz7FLU#`^kM-BtA0 zcb4wbooyMOT5Ql{@gM0p9zmsdrc0U9NwddJQu_&?Xvj(}jzg!;p{I^N$4dEneBG2f z8Zx`o)3H558-5*NE-3Bh)>HtC@$m|#sO1>w0I`P5+7~mYqSHO{CNIcz3j?y+E#BS+ z!UAUM)rIsmSSxOqi_niU($6p2y-Ir)>C6T;$67K0#Ht5aivCdR`*>3q2|-hQDP(S*`Dzfcw&g{TbPMAJ|CTKn^stYq%R5;a%vqwl_X;lkjyrC)MDs z!DbD*vQ(7yGKUe^$J{4=N_mwc(x=_mRsGV5_m6pbnO!bzC=R zvSGsHDF?gArJ2h^#&m~uL1Y-11#(Ip2Sr8;Z?J-bPtvf7VpX=lG5-k2e zj$DqYh^fwyL-R#QXR@JPfFQ7e5*^aIJKImV*cq#q0yfAK!nSZ~*d5P1#|QR-20g!% z!=>)CLc|4FhTCR6+ZMRUttT3d0Cv$^ncyNMD#LXI@MV43W}~4IHn*AIx&pF{KYNkz zaL>TVPAE-08QrL{MCIwpwQ%APedN416=McIHYp0HPJN~X(t@|LO3%uFfH5dPV=!+? z2@u7Mh^Vfra1i-D+1TXfVR%WS?c{^NBBZ%eRm6|cK$gwBQtB}CJypq3f92S~ z+sVzUltKlJwuT(SZOz=P4}=BDUYcC_z1;BF1K2a|Hsznr8E^;VV?~5KI@+6H85rDv zF1cc(CoFX198z(_mM03HjxC?6NVWfFZQ3HcCS;M#?{3ZtToFheS6b{at+vmFK|i{3 zeUWCf&kfM|5cHBxk9eoyGibf$J+#WIaEbBBemhv>xpzWQ5=wpEyLf&Nf%+L&zmXN*jGo@%FCJKA_ zs(b-EjtI4TGxIU4QJzB5FDGbxK^esX*N$IYPcJh3-TDLQXt$CYy~}0OUZc8;PvR1rX?L)LPv#(0<6dm| z0^D}{VUsN935#%^|M*60ZbR*!{?9FQes$&4rU?}M3;+YV_k8WpaBKn8$;%YIC5}kj z$H@R?KA|3_L^-5SnaH}J{8RdGs!3;He%P?QMEV`*j%yUIflE)F2fnH&c@G=*G_|iD zeOPq>rKf=|O-08oOKr{a!L;K;TtWy{e=k^goFiO)ji>Ml|Jar3nG`X2(p0H@SF;cP z>bxJ}?(FzYm+qu{xpzx@$_Z(4#kh>8bM>OO(&c%XylYG}4_oR=@xyN^*->}!zRq6a zl8@-lCIzJB&K2PbP5J-+V%CPenx^St+Eso=$|vcAWpDsQO;eIIgpHteAH7EddMym{ znxV*DGbal+4dH|d;5ApmTrPje4e1lrCojg%<7{mq(*!K`_vE=$S=>%uij;ub3k;ZY z_K{USnD0v8`?b&lqdy6b1*>zfz3g#(#FOmJJ#=7Vz(QfvnfJnyMs?TE25*u6U0nxk zSSWj{R8|`j7_gC`vz@#P1S9m}WUb5#U9%1*9P>P$hB2oQGZV9+Ies}zWc3aJcu~wzZ<~CRrSEQFd^UGAJ`OZZ5JuL4na;R3FaQx&C zJ3}_POc7}756Bm@(syRJjEL&|fU#M4QSA4v0u80poL5k&&2Mb!n9W<_MQu$uIi=pG z?M-YdI#BQQc+(Tyu*=ut5@36Hj}CK3PFBnN{sa!w z+i{SFzeLJpG$y7*!)sK$aA%aH4seTmNxItFE9~}j5b1bWz3s0W%ZVjhm_u=xZTMuA z_NCYAZKa>tUf;eK#GL~_lrUV*>l!Mz%0oLD(oi0c-=R0efmLewjo}H9VSlh+fBfn( zo@&J9DdH6BD}IU!MNU-1d$v5qsWowZ^Lw8KKciw(|4W$cE$Pw=mgn5MvILT&98|pD z<2JVc-S^B}*)ANM=f#VWF&Oc(fz_c@KE0f;~w;ajfSX-;Hl(VK3Y@VrWb;^?at04F2}~P-?URcoVRWixpjuS9kvD4*-|$h1Z&1EwrRP`>agEFQEPjb z&*v(}yWQ)J*{ca%4hoYnSQMmytH?~ml<>*a5YarSiGal4I zCt!iY4OGYW-mU37Kqf5fmL@&h08IyLw-lVq(yJelwuO`j;YOwGO!Qb2eWg&hFa0z5 zXnIAuOEaL?<0H*K;o0kr}X< zMLTf^ne%I0m617>$hBqMpUa^ZLTI@X- zP2$>3oaM{g)(BAGlh72ou@o!BhCX&nz(DQn_NBLhG+DH;G#}kJN>_I;EQLljh(|m6 zd&+hJIBnfuw2J}v^kiKa+M#9m{<+z%hHA4)G88O)c(O-3N`*UEW5Mp6I1uSZH8)fX z0r}U)AwA1vW34GqE`ULp1O2EG7dJCj2c*YJ@?fh|{OIkvpohSo)rw`;RL7-w9m6`E zO|Cl3b&H*L@VaCX=rHzvvyZ=Kz*Zv{9u@u7Lq5q0E>NS`RR+vzN1R3yet)nAseeCDu z8%h2FetYgfDM1WM29c;_P@TmmbMCudA|kzzp4E=~H#@9y;qr0B>g4iRX7~V;B0<8Z zrjL&Jqz(7tIKN8WxWBv8_O!Dii5HsN@Q02FJ}<+v^Ga01>qxHJML-AECC?JR58~@< z|F8IZ6$r5>7P>+>QmH#oOFww&{uF(YqymR+6C%)hcq=ywMJo&!FcM&B?lm% z{7K2shTM$+*~K5Sc{ur0DJn{lwL>DqpTGI_3Dmcyrv4Ov#6f-W%#?`TVx~P9cY}Uo(~F44Hczn7+VY0EBVYst7FF zVf7G^CVEZ1lZTR3x^pzYaS&vxG6cVp2@u(08OB|Q9h7|zo}%O+Oa1NcZw*Z2m@2+n zU+biVvL;U|?M6~Kyoo=T{?!!a!3o}F)fMJeMkQj(?EitPe@FWdg1@QiQ19WHzbYa@#xhvuq0a%kOaN5T1E*eG%V$hN=K@svV4l0Y?my*};wAb3+j;s7}Lt z)g0#@KUJRpzf2$xhL;%Q+}mMbls2Uz)+eW5L#?gkn;*x{dSbm+ey;dxY@I$5L8WJk_* zV_5sO(s>?*54ge)MFM>7h2%~P$2sE*_kA<&eG-(oCy();jK0b>Ju&~L>{<3>-EIDzijv(P>#D&vQjtzyqR;j^Wdy? z1aMuZ9Xh>JzVPtO?!h~{W)ha_k>dq%5K9*UAkRNK8LYz5QBzN!FnTW@%PT8b4^Odb zAO+GSATtDx2je%ju1U}omiB#L2}p-k`j{2l`hCnja6n~srQST}Nd*l!Gf{16P1tuN zB6Mo|taFT;>S2y~wjSDn(C_cQPcw^qKjlJ9>}-|jXnG!MF8$PnRrh&}{sLh27qh;Bm~ijKD$*Otbi zKHZG8eP(WUg`i398Sm|d5QC$VYEbj6GXYkcmS+VRq5!8JRwxiYU%kr6Rlf?DqLZw} z+c%chnBQKdq=_XuM4zgT1aGE$NzE?N#`nWxd!lXNIJ2elv$)K9ULlsVQ>1+~pG~+? z8f&KtudWg1F0UC_4+=(vANFprC8O~ba^oq4ZtxNuiZ)h#mzAvJpxP?HUR;oZGpW=j;V->4K#MA-wXcmz(@*1?nVw82Wqv*SDYAFJjkgKg^lHo6X#pt-uRk6j!6V3zagm$=%n_m^Wc0$r}kUz=U~mv9?e z-31lkv-r7MPEC+ZzSt>>56($7{rx$I2#28lGp2V&pTPo`?%BHYlAX)A3VJ4;>o$)M z>1gR62cbcdD)`j`&2;K~kY&wqE&e}Kuzk%LrrQnRX*+OV>ISX@L^GXV#_+eJ7_>28 zq^c4P9#ef+Zb}hMrOe;1%QiyePTaI>v-xh8^G0;sN%Qd)nWo+kO-iG?&dx&Bne9>R zxDqx>PhXkPfDirE*$b+AU9s<6TMs>fN8*nV>F<}`Z!NwbmUwvBN=){a?BXUFS#0lM zLJC*n`rhmnj4EXl;0YkOz)R*12dq|T+~|*C!Z&?$8=~hjkt06Ft%NmWEKS_7YGg>oj&Wz>w;9FoXM9GbdxF1zENu71E0$UnbR5f|tCF$2DB z_r;!zC#@(HpEuVerkUaG%sX9-vGH^dOGSYwd|p-A#hNn4X9R?`JaTOp%IdjJB8idBQ}gsT)jc~-!^-r0N(EWaf5i4bR@ zXCb!9;qK`Ws{11d!h!?439@pr>oD=GnS^nD~8~W@TOL)rvO?jC{aE|5oQ# zG>zRfcPVR=a6tdzDpDy+Rdfy;8=2YEI!Nwtv2Wr35cRO3NBjCH+`Mn${%^E=R*<*v zdSxHv(jNG(!O%UgvhzOizROR^niM<(tR$^v+8#tJw0vOd_D&o(I*jc;Nyo1+4z0%`3u*CT!j zvKOus^^7;Kzq@_z>5a(&y>X>oagcuhI2|PKH*XgbG!o!@TqE<59SP|RBRK&E@rs@V zHjzM$>{-L@uxKY&#F@t^N0R-pNudY#%KEEUE9@z5qw)Wfdyou%5gn(Aj8u!UoT~Hx zd^vjk3Q7*zL4V=CdC`yGTm{&oF~=H+`wkpeTJnF3V)b@fF%awenS!!mIEdm)zq+KW z6ET|1GG&=!1J`PK?NGzuKa0ilda-E#ABzQZ4gry915sNzZ|Z9nErz4cGgYQGDM=*< zYIrU@zTN+4xosGC^npPQX#s}jb=ExkDumMlTcsFE?5vV@FZ>1ec{g;2)t4twJg!n9 z^U>XV<9UkVz}M%JZc@a8(KFBoK=|3#{a(utq3=?33&At>+k3D!^PiJJP8h#QBVOT=Lm#F2DX6Z84JHjX4)gMuo&4iP0feR&okpiRM>1Z zRs#-So-H+vsHN!CEacxE?%r2viJ9*Z3i?ya&KZ$2$nE#|qJZ&yv>+g<<@2G?dkR#& ztAH#X&*FgfQ*K4la?$a#t4Tnwh1-%w@9NnfRt<6AiDbxaz#S8Di}%xxD8W%*#_NnB zYX=M-9&(fn$>7StB#6=aYV+lC$BBnwpUvjxUG6i_U!Au`^f$FKjJP(^0KMQ(?hEcU z(+z|0uJU9%GEt}JgX~h&1xx2$A!mDo-Q%bjVQe)%=EjqFH^ocXe{MKI80HV!Gs>8x~Kgj$lgTIJ*ag`8TLi;(7SH zbk}}&6h7#cS7^C>vAP>l%>!K4r|u)TYb? z7I@Cq&k#w7w9_1;t_r)h}dkX<0D}}V2rLs4iysZ#s8Unv& zM17QRj|a|UU%bnCMm+C&f^xcD)5f8Ys{|t&MnMnZkRU{$>>;pGGJ4MHTdidT4U9s@ z3f>xsJ}XhnYU$Ru<)DXQs^7GH81f7}`9zaaFfIg$FF2LCkiQEo5?H_<#|kpp9#8?o zK((yea~Dn@vghx6#8ZKx-#sD#INf!KDhy;K0J^FJQ$Rz|SlBs;&)2(dPGb!rLe@V( z`v}F}h-p;O`vpQ-1Zj;86VlG-J=_S5J&l#f!|A(y?P-03{Iq(;a?*Ur! zd&R2|<$uFtKX8W3p@D7;L=uLx%h-p7i;p?6_BET>jq84lM1|sS-}20{x3H$S4k;g_ z{nDY_@ao6WgV!P(vtEUB|{oD|WJ`va|)(i5dLjl5| zvXFaN3731)ocP4!Ln(edEw)>K2eSzzM-GhgQm|mqwY#j6(Pn(iBlEpK*!+zz3g%M2 zGl(MJ?#4=baAO!j&z>GzT6kr0$TL~8GZyV7oBK1qn%^dQZnGN|AhH!6y&Yrd!A4nf zIbXR>fg*omGKTJ2+Ts^%T8g<6k8fE*cPF$8+Z`S@^w%$hu2t zEQG<^lJJF%w9k5bI5+;ROS`|)OMwy9CN@-0N%gOmDTTThwE6s)XKROr0jsQ4DS2PQ z+14PMzB&#XU-4V?S3Wc6EbT zB-LM6_|AH8E+H6EZx0KmLyG}hK9}5UQp1H^u&Mjv88gZs-XE+}x$iI}caTHhk7ayw zm}4`BtH30tBrokYkaT(L0GJEs!fxIDMMby4{O1cW*A(*_fGePF2lZ&(AFR600f;M& zX0e5q9C@;8pfJye^oylz`sQX0u$7waDnJz6;6>k%JxfOMTYFP>zT2$3GTLT=jvc#L zhZzBDV}X~qYE3K$`zj-S^t*vN%%ScnRNl2tmLf|dPp4v^vj!u4A$|0qb&gv+j5sV3 z_*x)n?xsxfY8CR<`%LUh@zHW;08R{*qD%bAlT_ORXRK@5oXjwhO6|w*;v)2Mm@~`A zFJurm1$2KZTpv!*1(2+f`qDu@kAz=$m*s<8NeCjWu&L-rul405|oDkM=dh5?uCVKA$1*CO*W#KT1}h@k`J_ zk>tDI+0PQlZdQiygqiLtmNi$l9L!TNkwck;<#%vM#eLyw8S-%apLq3sKQ>rYEM^Y7lGD zH3*}Z6hY!mel12avDeH5ZdEVK|F!|g(6)=Yyw7Lu!5^dU?$bWNS-3(7LnHNVRSFEg z2g&!Py-7?_eam3L$i?~3ys=p#ptH%3r9s~Qu8_tAff+-zr{vwVimaXFD3XGH#To!P zFJ6~6o-@QI$tRQaE1_qpMmr9Qxbn+wFFK!be*S~Z#%(*9l7@Iwu@;)dm{?CBgqh<1 z^k##~4(5;9D5*wa)3C#z=_Kj>itlG`;rixqoxR`UKLnWb@Y@V%-^OmCwS&Tr9=8a&Lnn?WSylrzH^AhR{QMrO26f$@Sydz0?q z_AE7WW;D2ivpD&p7;Z9dzxWEny~jWQF(14#UX>0)8o%cfsahqet?9vw-Qq{40rhOa zKXvHX_A`)7#KmcT55vzBHKMCClOuIV`)fTCa*545ug_EiejZks#B^cdpGWLY zt_G~Haorj#h+8w{pf54@_*QL6Csb^63F{55&cH;TmsadMrF*VDCh|c*qaiK2Ldvp& z$vzTe7_(Ab$pyMCW>mfEOw)Bh_H;U-)pM^P!PF@wlH^peHT?kv8%di#G*pKK%gO^Um+$U+GHA6{(kjm$3d!e(W8sw%THX`c`3od z=z}rjdi+@;sy+Tz@bSq;?G-6 zqWZ6tx;Qd+|$Ci&5=0$0>-UzcdQde4JEQ<03yFf9q46{dqwhJ>TP|EXS z9bLYKdqDDD8@!rYFA=~aOSbPnbZSQe2e2ql$S(v=6@v}HSao3He>k#OFj*95H&Fu! zj~rsmpec@e&K&s?4)bUpPP@bJqRtI2OPlO3{^~P^tX0Cf`5RCNf&JGfHen=Z_3=J* zyfavm`dQ@Z?hL#O=LR^o?k*dk>B{IH1O7tN$zAS+Fyq6LLv zG?&^jI6H0-tBD30P@r4p7g00m>t@9_Zz4!u3%ttq_>O-Y|HimFLx~-6cyd1`eA7c) ziy#g9$f(&vox92Ju7e}~V^OMU2kOqeHjv!jD_K8J_#LJpaM3y4`IKyBmhN_=jG?vQ zJyGGXOBB&rgB{zrFh;`yh;5H|{*C*d&q^KK0c?LbaKZ^M>j>#YN#>bm!D8fm3_2x%#$Bpi?uX%Hz1r5mJ07(%2=K)R8Z zkQQVRDWyB5OB#k4U}nzmc;C4T$d7bRsIhyxyNYQ{lg*nP@%&j(wI6=0IY?t(RtH@WJY(N|P~pH}+Yd zGBn{gQypBS3&NHD9iX zW^PA-i{iY~d4r}GI*s+5KKbor{QMJqk6`42jDNuOI>*Gp98{z2540N-A(^>Z;Lg*= zvu**_7Q$rVrI2i#!o7nzu=V<5-gU0APne{v+dt0 zi{Z=P2NZjMkN_*saAGvlQcdri3SvApy4aFaV}5c+9~escgj80ka6s{IE_vqP2ygaD zd%bw$%eKFwCgC)I&3uEg$Sv5D-k$9{7g8H;;;jZ}H6% z3<_$O5Fue;SUYUA{7ig5U%q_MtUO)e4Kjzxx6*-)02Je_O}+YJj6dj(D{A z9`&t+Z2oHB9+7%d`N`lpXY-ZsA=qcH;EP&cx#f@mg6tP8Uj?2KJnT7&p z^1#skTwzZ5rIKveVPgxXdH@R?bp6NHQ>n5+@|2)lyn(G6%;~s^Np50A2NgKAc9Hbj zOz}5;PaJb4m$1erVCkHB9ZnJ=$xyO-z|_F;H6*ja=HaRJMRj#*(fepzA(DQSAG!oS zn{3OpKXq@J)Ul0d%;L?^9vX78x|X1@PY3p3)| zNTmeuoo%1324Orb0l3;>0{?6yl|21&(b^9b6qu|^m2q8gla4+8Dti=BAH41Wo6_`# z_jgg8eMaX}c6yqg^nCzZdz{6WH-AIz?@S8EyJcM zuebd1Aa^iffD$Gf+gG^xWI*s@yG;l{ zjK6ifo^ciHk9^e0QX_!z(Qf{diefx>1Ca!Y4(Y-wKAGEbB5}Fp z9qQ3|P|X}O0(;4Y8SvTxtUwgOmG<&5B+L9I0HYA-X*&vn5^QuI9M$LeJo;hY_(+*9 zg45pjClFr_Y=d>MaP;o}5MW8#)9`Xjd6j$^+A$USJFXVjUK>PZY?F)xVxt`LX)Cd0 z6;L2B!FM?x1c{Q$n0_LSSOgwm5M+Kw7%Zqn#r0gtbJrg|jyAIO!Gj)WquUk|WTtE` zS(xNHU`bqFX!hF!*(&DEQZU=&!duowN%b0R7#EJW4yD5`d@zxh;??#0Y41h*6B;Q* z7HjuyqCe^D&m$;FG_*^WdFY*8auWH~gUW7sM+tWK+;!Oxk9z&lKxSO0T(9$aGj@2( zpM;nmG0{BhopSo9{&M=7VHGnenrsH^t`+s>aT88@!W9^C%^+unT8CDi@~hG9LMo{O zULqSI0=|3nTx~x!&6a=QbN?YM_+uAfWa}+0=Xc(~(&>ibksZtSR;+3WUy~(h6~VXK zAzU<_^2a-WWuSY;^`o=-k6TteRU@ojC@d^fEr`&_-!I1Y$r>lgTPYqR-EV67>*Hg- zpHdXRbY?7{u|56ey}M0BV7jmcu}uBcN=s=PX^N8jeFflv<*2$rzpV8kKMlYD6&^93 z$^gsTo*<3vJN3Ti{?H4FodS$4PT)!=GS4bVzRBPBY5x(UF_{)*aK2~jyE}s+lwR&} zLfm_UfKQym-9z2){xwfS8ZfPO*%D%_oe+*`}(h_p)$tMBVtz@b|T#zG*1#aiIA7E7T^1J|u6H%_t4Fc+Pl1DO9jfU?> zJ`a4b?A$O7?5O-9ZAL`hrKEZcKR_z`JJ!yll=O^-9>A4^ zsi!F^Ljr)>0H6#@aOwS}lbq24;5nNY!0INBv+@lr4P4x;a#Np_-N4?A${f9I26Yk< zQYwY!|hg9=!D>6&wD??P43h!O!%BS)_00qw0z^%CR z#U~;#2wi&YE0!O39#y)jeEJ*YlKP7a$bd5Y4pDC_AJ%o^ZOSQ8>>(RN0u1>q3{*>2 z3%-^SyhV^hw-o*LDN4{l7(2!~Y*>9L`fEkdlD+M>+^v(`fvt9?_2mG=>r`4IlkJ_` z{<_jHfthB1lLi&vaU$v(-OiE}M*m%SPHe1S*W9`No#a~)F7}+AM%*dtSW$9+ z8vXA{m?>E4YPYJ{Uv6RMWq%Qjofn!wP0~E|__MRspZ%Sh&p1d;Ag31A*1u6;w(+{F zlhMoEPoN^exh3jt&G92fqq|IA=6D8^MLXO6^4j(A5gSie3@jG043#oqj!=}EDLXHC zmb8scro8>qWDW?x1ty?jpg8FJQ^Hw5|Mpa%FtlL3X@4FdN$?3mKm!xVdLT0WDmBGI zRS0^+*|f5FB732>`^Q-rSJSMX)*;XpiI`{kpBdXMTnWBdhOx@?Sji-kN>l916F05H zG3zC6C(9o#AKfgxkPtp5JcFu#Qv)}(l*^7OeCs>aXy`ZNypg(P2&m29JN>L87*7?V zB<^$rqXdELeSf+SMuNVyIlQ4wlIG5DWqz@?a1CV|>HTB7zqQvgJXIA4#_QIOlf2~Y z7R;+=j@5^C<){4XBv4<-l>UK*1uD-$Ovaqi-kX z5O$W?_xGBzsF0rlLNJfNdng{f)bAmGe@C_!mv1)r?O*Vbx}3U((=#WHQ(gfSmfZK> z?D{#X>zW5>m%_AP&(rlX@6*2m9iaQU9qe`=3DeSTFP`IqENn_Tsu%H#|8mTQhFhKR zK*0KD^&cR;t*Ji^4Q!17B(ZYlMt8J$psOu=SJviN3JOAxZ+B|LSi$w0Qih1=Mu|;q zqdPj(kGPEFsc2HvCVmNFOXr#0T8zwOdmVF{YSdj}x6mtAd=Jo*_NY(WrXHyC{0XQ6S9B??VXHeRh(8JW#heS66JYzcxk?_@mmkkT!%i1Ec7W+j4 ztt@hCf5-WJL{fWHc4o+7e+SA*^GWxK0OP^pdEpE2BMuQq>K4}zdtl)K=*M6%I1?}j zDk2ynwo6MH?9~=zPCM!xpHH`&)Iqb&_9*TitJH6?c|F8bs*H`G#Zo=uQ7bo~0F2$= zHKLIT@?wju!rR;YG3Uq=eTP@>9>Zo2j?ZWLwhv)_lQ7JO^QN^L^9HN*|FQsNA0ysj z(&EXB*|#?q@YQ?e$p$G?DO0>1!2ZBKJxZk=g+ERI%cYJ100S32->q9vbGB#rSnW5`7ZvIsO4}P&u`!cwSMz9v!ENc zYq9`1#TOQUk4uku_J;;@97k{uQ-%P)YVndW6;91hQQvzW`VMu1^myhh^pzE76CZc? zc+Kpo7R&06!6yRSGPY;`1dN*}dTtFCn}(KBb^E`gq(=eU$Ipu@!4zW5wHQ;t{fnCu za5xBwCC6v$@QuS+z!UA?EH}2eU0_G$S?cKDEN(y3jB&ko3A|Bd!Jmj9!GQafR;`n$ zEsuD=s;7@cTcozD@BAgCTSdaWtH0PBMwqtt^Zbo~^M4}X9(p@&>*ShbAyOg@DF9&6 zS`4-OJvzd_Yq+pB36V(dExyTrVcAKeTA=%`<^&T~%VE(T=NVk9cKve9q6R>s!kmI_ zhW#DYuA_r=!1Ri%fahh=8iC(GH;?D<%`*kkwxK6+w(~Kp3w@j-EQWvHakjo6=%*`F z;uTN|2E9l?*+mW20Bs7tW{k(Mn#g{;D9`8#%Wk6zQN-vGRqT9x4>c+D^F1=x;@Qu{ z5bgpdPQG!m3nKeQLR1Ni7<HFdpNnG%pJ&d5A%bDN|vdc@u#^nMKv7TRc% z143TJkO=!;UAz|3F-aG?Zk{W{`6*uX+1Yf(@0kMvPH$ms`$%k$?44&8Y~K14{?3Dj zr+L(Emcs%@{OOxcL=`@tr)+%6X=eDbc97%-&Jh%)VB6}j3#t-Ll&21OhhitJoAS`F z(>Qo~LSj^^6i=O6))6D?OhZFPtFWMj={KkdqhHEgBV+-M(|8;Tu{@b!U9Dvh_$rfZ z_KP|GQAL>WMNQqHLTN;I!`NMidykv1P{qrHbW8;P)W!Wy5i?w-gEx z0{cVqtFgDGFy1)XZ-6{KyNe^>#|U_5+NDhus+>!Hx(? zrcIEq3z&iZs)Uo!W&5QyD1o~vFpkKOyS{?V1Pfv&Ue_Ic5dD#Ihm)}o*M+d|0Iu~K z^DP+MTzdl}^f$~w_SAeA&ej1e zwd-XQ%hu0GPjCtM9Norhwt+Q;I84Cm_k`hNZ&UZ6OIFZ`J^Acr(0m!(NqAi15~i5} zQ8cUU(^wtS0WrX0{TpYzQ>+0zR#oiBS`oJ2uwlap;UH%v&r$n%|NY<}KVL4m*gh=tC?DiFm8t1X&t+!5cMP^sd6XZ~)j7k9)xOP$7g^vDlH#r?Zkf2(!xj6K z_3lmHYdVm19yQEZF-=}<6TR2|{hk=P|D(l8Jg4JZ5@n0wny_X(=cI5)AmN7}qs@4B zw~iw>QuDX{q17FnKu@|0_F5L*GOomUsy17<|XeW z)zBJGD%}0?xEih}$}oA&E9@FJvuw*rHn>J8b@wNU#!Md1y?hr;T9d-`K^g(q&-{N! zb$A{%q?D-;rz=7d_oHqOib^80b$hyAPk|eb##Z0{CH>109SyllU5@3HS|@TWE`b#> zUE_vmP>3+`87B6`)QhT+4CBnvmNP}%7)BC<7%#)_sr!6_@CtHkl~>r$^W_Zam) zuH;TBKLU3Jl&#`vpg7cEmXZKT!1a?NH-vB?ZU&lX8tY>;0xv5*4rgWbq`A`BBzg;r zX*2VzFDtGLKZ?7yOAu2k`qkLFutC=(wk$WAwW}_1JuHb7gIrUy3jJvca1n+TSiRH-BwhKNpa!q*wfa` zcR3Nhr}Du2CiMe|aE-0@q?=iepnw+kz4Ius@^hwljsa@*zA9hly{diH<%02u53jSP zWsc{=97ox5$JwdiHl?jk&qPN~ID@UqkT-xf31}tZQOC0{zEe81$c#-Pj3Jg}h_v=d zvfk-*#n4@xC0V`Ez|8a|gni@+`(?&^cx!ks68iU1({%nDRu=000c>F%R();J-)zzX zcBw<{c060iz54f{1!-PKf^$vTBf=+ry}2Eb&s9=5aXiD&%LsK^DUgf~Y>^Q1^wyW8Pcf(KrM zq=HhxW$!c20s2FF@+O;g0;Mr5J&hM@AAcylc;R>G-7UUPT=IsOd{+XUtngLP;WY39 zFq(&(7>PLZLyLs5I0oJ7#||&qbtIWyl+QuY34X;RXwb2N*c|3*?83wLw zo1HwIAa+F-O>sQ`jLVjL0;+3S$Mc^-gBdUL?Z@|4oR*6@Ci6T|9@UcJ;g5_8)pq&VMo?g1Jxs`&2?%l1sp(g`OSmH|9mYMoS04hws>BV7{6yu5Th1eZVf7GR4 zVQXLD^JC;TCJe{qjo-!o~M;Np+dSu}@>?Uq9Z1u|@gi5bJ%Co;{#cs~Kxd0W4ZKy}vw15LKSGST8o@D~5NyTvsmHPRGmh`r zv&vxfdl$gU_3xuE$Pw`_x5mUE)>l)vHx$JL7AhvfZQ3FRSX_hgCz%auJOMs~te|^) zjAf2j!ET)xw6snxK>pdXZ3o&m5sG_DTVQ&8iCY=Zt^B2q|E_A7QTKBmt=~if25P;j zZ@*jEr+j=Mhqx;=sv_Hp@d+t!412CK^RCX=p(@mM5jRox*TwNsmijkyln1X?Uq zqYlx@!>|+d=2YtC!bs}IL-}1b0vbIb23-c>AHj@^e>U0JMQiV$EI2Fm$?nnM;?#ig zljkb%B)4KsUg&QBM#E}N!K@azN7%lK+uG1I`_3-k%-D%aOwdt;gI*#PPJG_{>VBzY z4Wsa<`1cn`BEjOp5TJ9;~gRYx;prvZW(v}R^~>-Iy6A48vD@x z?Dz9o6y&1C3IlYJ2zSpu=-8^2!MxYb|Dm>`|8oR}@jsqeH$*MRhsHEkRhFi+`<|7g z3!ga6x(@rghkg%#FKYY-_ZH!X?m^hyv75^|X~oB%DJ*kn=(en4pr0JD`rg-fH`GAC zhpbNn$4Tn@jS`qTg4vp!QX4a`jxB)o-JEZnTVcuht9;WC#PjmF&%H>-vrBPH1oWY9 zCWd-@S>Ik}J^Y2oam@|`+Cu1EEL6(n@EtL@VUC8*!eCl8T8*$bT*2}T#C|9_uriKq z;k`CBXWT6LV(-jcf8QY9D!;$aWL-{W(szPI|=CEq}- z8!MK^_|@0Sb;!5MKEwe47GK`TXX9ocA^Yx0!7(tRnGoh>p%@@GXGHGO|4q!`)CE+x zTl~#_MCTdr46N(0eJoaT;i1$6Uy~?c5<Rzsv zKOpoYVJ75t=|d-z=^QXBZ42JuVmd(*JRtZlxob+&Fimz1K4!wMg;dB-B6u60>}Jsix?ys z*0yCQXU@+okkmjj=B>}eg~u6N2dBb99pE~AaE)-VmBq@z^j*BkRKQxf!kLi31fm}1 zK7Cn{t`&-#v~#}$H-L0k4AXGc;YGI(CgO`qhgyqfbeWU*<9H3K)cec3VLt19BJ3G% zCx$pz zvPvEr`Bc`Ylv)PQw%foBq-Vw6b=Yut=k@1;T+8e)==z8uA%d@g&Z3?|h|j=pAk%vs zv^u3{4*AjG&F_!sp-?E8R8er&%2evK0NqmdY_u)TBFBWqn!=5 z?Ko&ZA4dL@n`hRN*-0J-HYv2MQp!T#v;fU*fDmYeYXj8u7O*ZmPrjhAIr_ubdX=|f z0Xown5{?2d+dMeBmRkt|U=}Zz=`nD&M| z8dC8#gDd^gX;5v}8|;O&@41QjqK%8{DlE{J2v(3RJF?iB#SCb|Jk#pqfm2);(w7v2 z87{zsK~mc16Un_6#0HW4otg`IP>FHBB6c}Ubsy~F5`nBMzj6ff?qcc>7h1@zTki=t zK$QER|N2c&zqH9Sc|5YG{cNYIVvNEJ$Gz_hW;(YuL{bjZv|j=VI=RCfL-11xs*&)3 z|Kg#7z0_nk^o>=q;sH=b6yH_=;;v8&)+Ks|p&5k@C-CrYSfbiSvb%&Y;op@NRy`Kg> zsZhM=^)L8UT!XuN_bi?U(Mwp$f$2k^V!2NEXqN{CXq%{)Z(5`Lw7BB5v$$+%p0%%X z514N@cRJ4uy1?P^`c5=?47DdbjF1Xp$mYH2wDm&YW7iaWZauKoP?kpe8OQ>Dq&T#_ z($6SQq4UYM?{kC+5u*&zHA6{j_q1)}o=21|^ zA)+CG&f?9Tuyn0YS9BtQZA0+80S!NnuD(VeXeFe5holk(nK_JbG zyi;K_#R@KU^9x1t46&cy+}sS5VrI-?pBwu+X<-baNyB$BZx(Zw&yabZU=`)&k>m@m z-wo&($B-;cUmhU*?QC4F2exG9$1)S*INuAL^g+3A$G3iFm>+ zz%=wHp^k1y(1Es!PWd-XV>dlDdgHS9$qq*!+i4D^tfCKL*4dmvQ(TTT03RuO4u43ODp{e{&pjmXrd}ZeEwF;6| z+7&jkfKUE0#?E;n$#Kd**u}HBg8H9^wDU*+Hv-AC$PYV?r{Whi#a=Ut-OGuYfBDvu z#TIbc(ysflff&0Y`8@=L%yhjmL(3UeFR&N*>o5-lNZ^HCxSha($ov}i$c193+YAE! zNkqDStoj6gH&A;7vbmJ@F3-%}u7omx?1lA*%8_eaCeGSI3r&3zb>-J?n7*;W6ODyY zA%ZNysD1m1u%W^4iu1A<(D&dVYHPpx3sW>a)9QYZ0XdT3e0g2Dg!$By8EB)1VU8OB<85aq~oiYC_Uo8b8v8ajFy7Nn>DOdarUGK;PvU_nv zukU9x8!$3l6$=VGJZOAlQdbyJqWoFSHksuaB#Zf%i!7N)mVIdzFyL3{pX7eODr;cB zWu-;x2h%A0OaPeZC;wOnG)M^ZcDdeXX-2+O^cQixZ6S-Na<3|Tt+R{TxPx-!{YV{Y zjYhAfMIE3A&9i1JYRBu~5LAYaps57Pq20-(x?0Yh5}osgXZq4e2_THU>57guY8&8Z?XbIvm=9WWVt#-Sj6)g60an59Q}Y>cQG@I%BQ_ zZ?VXTb)~pf$fg8J*o1*hjtdPw(*M!CuDin`WLCN9B9D6u3;^Fah6a5`VA|vI=M~Y# zGFWBDl->sBeu1|f0hdVCngzscMlt$X00qQS)k|pxI9lC$SK^+a5GXL?QR`KxDXz&g zD!cm0P_z3vo`}ypwJY7N+iACrXGK)caFcBgXrbZc2Un z&c-SwSpzOQA^GIieohs=>Dg!Sn^9%5kXVmcIu|NJ+c>DyYh6yK;(>G6L8GLe^QFU; ztc~tnSL^OqL{au6!Xhpho{8cp7Z|nplMr*}14)uD;?N(q#=%+NqEsDiXtXTgS|VTE z_9@${InWe22T9W@hm{)%lMcO4o`P38bkck(#u%J62@=0~Q|rHL*gs)9YS0ykA>W_{ ztU8?^Ft|!Df-SBw8m_ncxO?5*P};0yJmlo-%-e*K@B~_bZ*%MnzT_%aFGPv1inPZx zU0I|PHr4rGUz<8}SO0NW#7H_E^l;8teeQ;4f&K~b^CBEWBVZWR{thm9gPFe^6v`=2TPg{u4LHq&NB}ba zKxKj9G0mD=rDx3gh{FdO;$&Ta)A;);0O zqCcyZKZd%s9CZR*9Dm^H^kt^=j?9{u>-*JVg{9JAMcUbzlhEru-#I66+}&$gS?D>q zNCFOb07JjR47ul_XuqV*HS_kZ$)W*cc2?$~6T{PB==6HrkB3h9a-hxO*(_I)C{}QMH?CO*(j>E^{b=v(Z`%kju}SDUJ{lF zxC=(^Da!wL!HXq*iq-HaqU{ebLhdqY@>sLSt2_PT_HO7Zc~)-iJ0sA-i|J*Blv=3< zs@P~;=TxOW)NXxME%AN|s9~{1`TyZ+m!ROJ1Eq2joxHEy9Z@qzo5ANEOsXkJWmGAf zbQXWO#h)kC?(fvzJ_Gk^l9^mRr+3AkZHbDk>uOR~?Aet@Z5LcX=Zf=ZsG3-8-=^3( zTL}v;oCTn?e_}fNCsoBz37pl`!z>-kxA*yUr14DU2;LBaZM&kO5t;Wy$jGF@loa^P zQunknZthuKvC{4XD+I7`0YJMXGqr61H#lgeeYm)KCA(QF$%oBVH4Tv+LnW;H2XE^1 zx-7sZV42$x1mkUU`opxWti!_9I1gs}WQcLT?`@eZ1_7009WW=GOm2eGqHl%^ z2A&HLkg|8g3LJ+@Elne5JcCJN#@Hl3km>&$V1&_ty-ryZpswmJMuKsH(-bfhj>kN+Q< z8V9PwGnDoZnp*zp)oE#N*B!cNJBnHlAF2E#o9IKv*{*)4D(q+W#y{cEY^Q5OlI?ue zo7a8zDMof*zD5CVINoEzUsyO?u`OZm*NXwC<*qo}#+U<3v)3xW^d(l& z#P1>3Y6P{#CiN6ouKz%jzv6#-5cZaqc0b%o(&aBpSn(MLEi%NU!N*;dMr80`_H_uP z%*-Lg=NWe2znta&a{zTV?V9(A#&1)Sw?ij}(Fk|b>jk1-XT}A`kOYDw`Iwe0iGLx_ z_(Az9FQpI5aH=!(e&I8V-2>6c<8K-M0}B89YV>GktNhn42F#a&`0Q?KJtW5+E(}HH zhn(1;DW3xMNt$zbyqlN+4I1|qI3nHjc$tb|r+@j!Bq;eDF$Z zKRX}l7Y+tay7X8`0utv=Wa*k#rh>;~Yb^G6eE$K3gK+Imib-CLK9>KHy}^-cWeWe7 z>4u{J@x8$zfP8Q8a{eKJ6O#Qs;OT!3 z5N_7q39cN%uO^WN1iuiD#`e?A_&vXbDjpPA>MBVf-=DdiKva&Z6W2dP;y>z_8RaWgeKj;8~%4!#EB<7 zRB7D*gFOd7B6(}TzP?sZXobxNeC4b1H=jga2p?M{6eGlF^uk2NZao>F9-HHlI`uk(;r0KWqiF5kK^e~O z|H3PivG4!q0Gr?g1kul*h_Qu5pa$ey2b2x5y!5fmm?u)=Vld{Jb3C_RoVik+Tz0)b zdC~CQzVuo_(CR)LC7dm+e2rhW%#?c2f9d)v&ej;`2kYerE7Us8Mt)*?lv9tPd(lIo zG)jguBgHSQI`bOgBFA`-lw%nL9>1T-A5BG_LC2$mqF3&Q0Yv#!9$kUk`E3NV@?O$h13Vj8X?;wqc?!Y8(QxB7($Q?F=`~U^<|> z(VmWBvmhfY=F~Yf51X6Ng!h@iOr%hdAVF{^9gh$n*X&eF@AJ1f|gi+8U3@=s_#Ru@YQkUauotg`@B5!oRmRn2fO{V9dj-mPKu zb=?6l^<=OD?03s>mAL>+{6v7I8{X~0Y`XKEA4xRqoUU+Ie^g82*FW%U*|udBVvXt^mFxfMMc2AvyI%ybPv3Dv)dz zbu@|A7K#W{{jf=#)sdTp*qT{xBB&*b@j~1H7rV}l_}4eWDuv#2cXNTRPS z?FJGrPm@5EwhA$iy0#!c?xku`^hX_I;_JZnI@?V#2!Zc?~-HnkHI9hs4!cuO$Hi?j-yO z{r5@fToi&}*Sy(d5bZc;A<1Bkdq%<%Yn4S?Nd5ZbP&h|tUmV;_s$gO4NPOi*-?EiE z-F1zjT^bS+XeHaDp5nN;A)BjLwXh1rB0G4e3bAuusAHohPx9{nddB8v27BBSgnsnB zh2+8)Xg=prSyJ`GUwjw;MdtSwvX9YS=A_wlpC-FP;~ysdbjJ5j5= z2*Z>g>0%qQ2zGP&b03&;^a8nyHMIcD4-!Po`K?cTr}*mMX&QK#E5hx*4!xk@KNZS?pylASQK|)?8=#f#t#|0 zc`7tbH*60-i>d29r~g>SFfs7rHhICaB!h{}91nNJeAc4>Uq*Cc%l0HIX%NlnV|;-J zF4rf!`w0$-jpvCxo|MIP=O%3;A0*2xt_+s!$#0-o5cmiixnYPg7YU6u?DxIfdguKD zd5^1$%~YQ^Ee)waBm|n=J3BP1~qbH8y2?#co-4+0A+zw9)GA^e!<-ezCx9+ad}l*5d0rP9*N9NqYntAnd3dt5Ny z6j`K1xMnjbr<$Q3yxme~A*4s&$4-{Rve)|>!?VP=Y;=p7JJNavu9f0^KMf$0HQqnb zW$IIdyNSibxV+q*Dr}dsEs7Gh6n4e1Ert~h$U!wh%7ygy8w6=Qw$yJ>o*rQHCkkLUx0 zr0*W3hA$}5*d2G$7bO;b{0)Ego0Qg#TLf}p9yC({9k6@r$27jp>6$Ya`97vg+~mzQ zM>zzt*PdH!%?9#@naiI-5C7)j(tfvG6`p_^4dp~G5d+Majuz&iHVtli1@_7EhkMQ5MTJ?HOT%Kwk04GI`IpLQQ zy!U7BXwNo(4Pav0p3UgeDQ0wjhW*+4{_FMh2WFbEwodBQ3s&ztoog}CM2mvBny241 z8*Au%X82M(CxA_DP>(WCDv{sj0e0Yf^YwC86>O7*TA)&w+3ZXPduL`Q%Rf*P$|A+HM+=&yQr5 zrcRb;wx7y`WBQyBv%9fw6zN4zpzR5D?*mj&nqQklU+LtWPZYIS$3bM*nYgXhEqukN zV#WEmZ{1GF2hL}fEyL9(_-0{lJkGC0$-=))X)In-9KH7Yq)Pzo<=O=Zo_^m@#C{D@ zn04bK&p@$p`7z@*f$h2$8)hQW@F4}breC9Kq{g+5D?nSq;rGJhK=$}%R_TCp<#K%c z>+7mLwC^Cis_6Rramx*mK6)wCaWU_dIV@VPSYq1y;T%D?-4GV!ZgL*OvwI*L3R?hF zZzboniTY$#QC9E58i%nUt!TP5uczx-!XR#&hI~AI{9!W^vh^g{D~&0;0I?r(_!T(# z^Yw}00W82M?~mDti>(J_P)F)iPn7>OOPuS3leqI#7)Z`U2K; zbP(j}0q48>RMEg09DFn919}D(VcO*acrI>3+NOh>*6Bu{+N8%>4SS`d0lD@8nd**rmvJf*$?yQm?OqP?C(uGe(~|VmiSEK(P-x{WL^x3*NL~a##f;`mhQ#h z25VkOP2{NC?VXYkDj;h}B{P5Q|F(FM zanbjwgueauE$X@y?I10QYe*o+u)dO}G&(7kT67nZ9dVi{Gy&d1_hj}SQ|R)|Bnr~t z_ci3;YYUPcKBN-Vn3O>rr7lHZ4D%P!E^x*)@4`SDa2oao&e1R`kB;sJ+D-ygOJd%O z#t7rIJD@KQ*OjlbUrZjnB)C_bO2$U#=i8fCcU*l2H?w{vvgx-aRgsTNIMU4c;TI-3 z8ODZ?;fe<2WfNVDlJEuzKXT#7ws@dN-KN>9A0`l2d2yj@;3vH~b+98*m$r{zT^J1{ z$T7B$Zxbe~@YQlSBNBrA%FcmR+~KGvk}R;#GgmG<+X=To<@n$FbaD<17Ri&DBbCc& z{Q2k|67ahK94Rt4+{6Ze3-HJ6?J;m0DkZmpf(z^cO&Isn@jgf(dXtN#1XPXcWk)QG zf{k#@H*3;3rgI>Vx~~mb+xFZCa>;(fXOZjkz=K412!v78<%WV$q2!ii{X%294+?YH za&pO~{0(mLAyqB2#0~=wY!J zW6CnDIF*3Vqy0f&*!&pR@wdTjHv28E!7uGgRH!&?<=!j4jC)=JVwP*>v_Bbm=*^W> za$8WbWa6V6HWluc*B*ayyP=ZNQcZcj8l-%ui|0UBX>RE635!66O~2#YEJix3tz}rbjYgp2(=$` zGa{kL1O{fhCg_f|-I^A*EEW`+|14}Z@Ob|G3!G+4FN$0j9|kZ);ybb-NU+3+0PTSQ z88e`$RI=HvbLa|K-%YqN9MjT#)0}ga(hj5h@2oC1|83Sa5$B&Ox}=pAR1x?~0~0s4 z;qu95V_qvf`Wm}Z4R$QTBS%7nBXBu#`5x>_^Pnv- zXMNV@8CVjD>Yb8j#p$F!JP3lbEZ}E*!i@#Dn8JmlNI#aTV|m+;5VjZ*7n^BHJ)5NZ z9#!l-ZTO0X)+Ag$qTN2bUmidwJbD6Hr3Rd28Bryv;}Oza!?rJ%mEJ!p=PUvwAOUY#r7h>qjWAf zaemyA_jMhk$4Kxi#>h!dqxKR?=VmK2os&ci(jW9Tzh)pmeA5tBuXUYw)z`kai;Smw zr_p)2QVgQpY{IU zW$g!EMGKro<(Zs}GA6K$&^FfJJ?ja8Gat-(5>_pwd1EQIISn@T~ zC6G1#_lG`yXHR|rn^hH*4AmS+N&@DASE&M^L>DdATmvx!-BV^^!Jb&Ir8I5hcuNQ> zhP#Jgr)B&3R#s1r&duOD^aj{}F!By<-zN6c1jTdmgCcDvr0L2x5K&`6cpCXm=<9*^ zA$;@J!!!;O^hDg&QdzdmisoXvno2H$K($*2nbb5sr_0f7J558w z-|?gC#x6yLPOcPNyUk z4=IJYtRKM`HD!E$yq6!woq!2@7dlVKJhi9d*~FP!HM%J~Hpw`CtL3&~gdV|7`rSHf z06W=2GE2`}GI zdt-Sd@d^5=UXNf{_K*nglL6|E_U@5%5QdD`t3e~KEmFcEjxpvQ2#EUhc-6@g$Erly z=^B04fi9Zh4S^fRxAJ6Lre%y7mkzgpeKSO@Eb{!}j^y~nnh>^cwRBo~ zDg1{qpwJ7Jb^sVhyoQEBvRU5%Za2VPS1~7yE{$^mM$uzW3uhA80&aYF2a+$K?}~YM z9e<5K%`kYBP~e`w9Dbe_IMVh8@K@tHylr7v^h9gUgjhx^?k-;d7Y%21 zYmV!TooXs;Hs$|>TynnZ9I%e6rJ%DF9rryy3T9&6$@u$ut zk(Gkp?DMFxoKq#eeiF%pBkUf+muvmRdxP=o^fB4(f&OPsT+4&z#(G_e1{i}D4r5Ot zrX(c3f1{S$<4p^YHf`|yK1iER^gjDlEd4&5b2Nvyj4q7IW~jAFGC4*nSmCp5s6gSf z^j1UvkhhfRff$XkV8^AuA7u0258BC9Yjh1`O7z}3Wf=u1UBw8GP@0@_9V&2IhCa9#rjb#W4B@ZEKsFQNjKXmgDXodwBq@ny>sE!0 zO>y=6Dk==_;y2E>t+pP%cpfv_(k3Hqqu zfltTR8Sr1Kq|@S_phDYCN}CH#Yr1G!`2`qys|1WbPy94Mfq$?3qSEuAP3$vA5g9jn z%E8%?u_Fb=E`JlDvnuBN6h_NxC!QX?B}{um?gJ#+5A_n2S+;ca9(|1;5|x z1iL*wlC=a+B$)KiD}~wh_iovzeIw4&jA^2ltb8KjDa5lDgZj>=FQFKy@WYazXpEHF zT5QoCBjqNhZ(5yq2>WFy&K!!{iv3i5_F|jAJZS&}Q_&XF7dp`^;BQE{1ny|Cnzx4| zu%fM=PI10SdZ53l(UI}(%dK3H?EE*9bHGRrQZWBK!K8a-xElQ;HI>wAnnuHWmy6{= zkNX8S?PSdN_g@xy1cs~!90zOF{{fai&X@5>rR(RJ0w2O&o#9mmdH=tL1fO%Q3qtEz@jE z;CJ5iL@Py{PH*c)YnSKmR#fCa4aAtz0PJRapwPsUW%zGITKy*?&#_WKVWDXO~B8DXy9Ccn;fV3YUnq_Hl8wSXBQJ$20M5l*871>tLlun3H5^I2{nUs9`Qtwtqes?tH{ zW$7qc5%R%DUm^SA=`@*#9pQLb(zpBpZGM>*!}+amO+TC!KNDIg)&pBojbvU9jF2Tl z4ugXvw)%onei&of!?`)*5h}o#Dt@{X-(Xdek_(-f>5rM3{($HGtr07lHso2($}avw z$SUlDih^u;qmW#CI8-NOJ9|6x_oq$@3R*m7JIa&^AW!<7Ir|70`dtyE^u4s(Q%NT| zEVdcnxsSy7nooxD)~L@(P2RVoE;yb6#XW1(2YVSy>7B?Fd5+_q>2mG%T%A&fVrPTf zbrk6~0Y`pcSHuLVG~J*tTERHer9E6|ld z5Ps+L1}0vOHUz$B&s1m^B?&VC+M=e&@DH!_Hy|0+%+#SXHBPH`cCun&H*mrobTetT zyOsc%9@AccTLSFIW)qxge+siwnGBMex0D#A{u8c(I8Tv%l*q_j4E4J4O(cxM6xzFYKn; zAk1D4$04g|aB_$%?zvhg?$QYiERp)e{Q*Zo^zz|fJ5T*H6}$I$V`PyLDMl0A1Z7cGl?h&pbOZIIPI5vK3y0B=S_snu$3+9v%~muj0D8pFpfM7p!H) z8+9m>6~iqI-%U`P^wvp{S}Y6E%Z~=mZB+x0FDC1D9d`~~ZK7MgmQ|9GSIvdB8g^TS z@Mb+hSE9H11hI>1UrPcZ)%bfmU^+42*puR%j_c7L?J29Z!$VMJe&36 zo=Lhws= ze$+gNLiRavp3Abg{Y>9*x?9nA zBrX1AGyJ3*CGiEBp2LBztiNHOVly*#@=`TfO-O;;@$}T=!|Vt{iD7YW`>+hktA|XKM%WC*NbTmr1rUA z_p%QSUGB)V32@&qk=CxUak39w?kM}`-^8iybGuP(lO3tJfXu`5?%m}lNi z^o3F8ikDUXvJlla_U#I&U)(7r1%E^-DUcsyXnyFM`L~JQc-`J5;oc3(CnA^ZvwVAU zC+qSFp}YXiBQ2ZyQwVL@6KzMPYcBx5ox|D*pj1clE%z$eZY?+R$M(jocjIfQxl|J5-y{%wVKp!F6;qn!E3eh#S6|{K-4~A#&pwGMuCyjo&n6Mx@ zC73p^rzA3>yld%;i_gPK_)ObYUhE_D1_QUm;Wc+c(j+o{^nRP$!c16W$Ns*N{d z5%^5tlz-E4o4${3HDf>bMff?g+iv;734g}!2yntzm{yAT6ye@W_=JV9lcv8)A%EB^ z`FYwY;r#z)0aWyBJqT#zT+mzVn2#TN(V(%mK1pM3{J8Yf=n8`!`)>H6`UTXVazA@O?8Nu||7w%IR%;Mkvr3q28PwWYakZqwC z&yaLwDyKko_VLiGf50IYi-Q^%?qt z({EmH<7@qK!S72iA8o*RAlN=(U=(iIH-SnV(1I`89#Si?R_+Pas{_-P^WhoCFa<@6 znHVfwM0;qz;6O<)#kl3!kQn1VgTkQW3;hM)p@94~F{kQiT zCVWZn?x;s*wp;WZrgRlQ6p_(*E0C*pNRp`$y_^(L34H{|V*U>&uKy1w&inu3#O;yy zRbT~*a}$l1xR%}aBZHVG5ZoQq&mJZA5B9E4iUwYsUC14J;aSQs*f0nFvj5If?SP}D(%3E50as~5AXWJSiX%l?W}N!PyK&K~ z5X7ke&qk#9<^N`1?f;#9G2Ab|FP4*`2;7(>4tD~fyn+c=%{eKp-21l5CFaznpM^U@1e`Yi9A zVb8S>Kd;cwOnZIvDDRw3dS6Wy_i3(=EnGtOcd{#C|p7~#^QQKV^I4kavU#k@ef)I02?q3_ z>SH`%7e@Lin5NXqpMCTGcFlebV*FYV*PrzROZ{S^r<58(vpSjmlPxoAM@Qj-`+iDIyEvrZbFL*3o0 zq`wyJET*41 zoaj3A#^QNxYEbOdaqu+Jy6UzLh{w7WJORqu{qj?jxkQT9wWe)q5peGG&YB2Tnjg(=*iTL^uiz6s&36CJu#z!dI_P zuH}v#)|tEK_WKWD2zR*|euHGB2kX0w{5{yVu5Z4sIt|XYHJ{7Z8qP^anH|U}-y+zP zo+3Udps3#EO8csd{V4Tcv+K%- zz;EIaO@3-zmRvYt576?R#2+j2mzfly3Y0M_Ox8hiU7=B%CRc8%g7|S*or?%0nAw@U z?53c z=FN|gGpb9tEL=DSI^tW3oPCJRLQ&ogXG8DHrq9*cS?P|EkhXPlV1_6F%>+)~dm#^g z07QV>@}n(PnP-?x7qEbOJy%63?1S$=!z?3Vk#_e?2kA*|1DYW?EJNr@cB9H_Ss=%K z0T5S9lOJ5`-1~9?g%AIsYA=~HTCsGwJC+ARkC%dwS9>w_of($*MIY|9B3${?+0RD+ z5-s=n?WT<}2oj-9y0Ms*_9$)}3H{7_m3>=GyussXz_RYTV#;G!1APbP5P!s1uj3RI zhYZPp9R~Y5%J$o<$V@P2m@1>aAIf;iGA-#>;E`)5b#VOx!Mp5IU?losv5oQ> ztA6eDqfhaq3+4!;ACtFW>(S!k6hPD`X;Jljau0(zy2wlWiQv`aEdjRbufFzs0NEnb z<~8xel)&l&h|X+J&(wmbiEMGLwAcf%ElppEov(MWKBrr!i!ZIL5{Ye|-;kEsxPHJG zoWL(z{UtqRp6Lhl(og76oJmlOCv7(VkQG&+hA&y4coQ3Mm6htgjPTgN&&{q-ZvBb8 zxuN+kIt4?>ErTYP@B6RR!xG}acXICZZuCQ~dK%2N(e$$2@9c!MRYVklnzqlJNw%4FsMjo5J(Pze*aN)tC@t*Xy4WCZ z^~D@>a>1g3l-yM1j!j^BW$)_XQ#P=-RHB@UT`;F+NdAF2L|+YYDGUf1@uz%_?3&$8 zk+LF;koP;U!Bom5h_x_T#bfGRRg!w+kuYxN7HKXFdkJ#wV=ndcurVI&^vU6uGU%(i zDfMC3a4`_*7h*{he92!brSkRS8@-V;2?SwpdHaAamRJqg|VT9rb zJMFO+xeket4i!B)-}X!s|3m$If(jO6`Zs>cv9%3^3NV8|4y_S1)1HBB7cx40=x7O- zHQ(ihPB9V|%{;m?wweG|4TNr|pD?T=0*U>vtxNjLaR(82U!5KiQlK3}udnR{+=o~`#&@Tg z{T{7mmx85_nE%{+I7f_tA@UI=UB~%Oqfs$5bC_4qcf&4X-x+bRD(QDj^>x@cvU~b| z2aep370ABre7_wRj*ObRc`Pg_H5}x??@CpQqOzQIUP;XnKnu-6%g`3v){~?=OB;1zYzGeWR(Q=@>f28 zAvkY@?0Z7%o6geA@18w}*$*Z7PO4i0BHi25Z~JGr=kH{p1>#9Ru3=C0kBGrc9=8LZ zkk?WsHAJ{F9q8ok5)moPrFtww`x12>zFkO!m__NmkLM*PdCagUCf4EAk$VLoJ}p~) z!EcgeJQ&lIR9^GH``deRk2?8GogYq--8Jov^%h#6leEccE%-#uE-HPZ5iFC)`N}xSR+w$t{ zYOmPiX2DHB*gUi`yit9^sbuKxPY>56gEq|!2@{(dF<2tztyV77|to&Mq%TFSZT2Vt}>JoCWlYV4{ z!GzYl4!vr>^~GQxGAj>i(d2fFPxmVx^DUf4C9r3K&X5x01>AA^+miU8kZ0M*n+~Xe zH8vW8?7rehQSV75N(Xb-t=9ho~@m1-_;9{3Mivu)E~wbFYzHe444C=>^?%S?unKn*pGm#EZVDM;hhH&=z| zZOv9q%aG;_^=a_<{LtC~`tgEDYMwmOb`snKK+@U+gJ60Bj$a%P(bS`ruLvu$@i_Y8 zG))HP@JEFQC7%H@;2*6<9_7FwPCM#7vs;JA}UZZpNX92MqG)9-MPN}piqAX1Q$ z(e#Hh)b?XYU5kV4g75e*-q&@Y-GSQ$w6Sy^6d4i=6E4^L@`&F*8Gop6jjBr zy37D4Lm)j9hvUITpqE4LRq5}aFFBSTEHfc*rM@(8pF#d{@s}<2XnCvx@CF%%H+=gl zlA?xvhrh;?EMUmc>jqzn;GiTxs&%S&`38i}KLZKdGH-bqUh&F~7{Ba|`q>?iSRh8wz{8>U z5{nE@kNFE~Y0x(%eXr@ccG;Y0x_^e_+E)J@ebjn>96HvII&cp|LB}(>9XEOS48Q&N zU|RbDYr*T#WiEePGb5LG92yO}Ouk9(b5bW6$x`V+NXVZbX_!L|)h8bQcq+An*#U6o zr{BJ)W_B0od8eV{!Z!(v*(nA@7#}>V;Kh9KVCW1RSnCZvfs3K-ir)dTu#;lK*d+#lFWK{Ul4mt>nzFQc! z1kWMq-qp!3AKk&C`EOS4587qAf4=bk4fzhV&QR5kv{&*Rsz565<~7)^=)jBGhgnbCd(cIg0KMl5`G0SXJa3 z-n_m@nP1&dyaT3HuX)&~$iM%%P>L`&cTn!kCTO6mO>uHsPFU~+GH=-Dw#MSnIx zbclw>bQBILuGm%Kyl7K~IL!g_k6?rx(j2&X7qjz-zM zI;|OaoNRQ5;qW&3sj*XJGaC(Xio%~8{6=h-wJ%+LKCW+ zc`DZw)lQKV2`V@!%S+M7!wk%t7U3r;NbWE0%b>F~j(of&?t@-sKRSIxM=#~$3#^j3 zrTLhVhEh30hfpi~o^fm*y*~(pA{G(zQE)V|3HNzaw&vc56J6zBK(!XI62{bKXum$} zpV|g%U2ECw?#8m#3EoW*D;fN<6S&$q1YT^^WM7-5ajds2mJ}BHuM62bAV**iH&Q;S zv{e8atjNhFIV-kf??V_nh@SZ}!A=Lz)G|Jzc1$78%p(h1t?znI_0df z^X#JKCUF?x0#KimN!xj+Wskq?A_Z1)tQ}-hpT^w@^cYyMnFQFLFohgGo68Q&v8`ue z7+*$=tHFYjEY5pOCvoS~E891OMn<*HTo}bR0xm`-1ixm>|ig#jxjcoLAM1 z5%f$vf<-qQb3EeMOXA*iku9Nam#st%akrz%;zsFRq$S-;R13eTD{TIv@Nlow_37() zPkD)tt?$|WiS7EtKH`49xDvW6W^F!c?|wrtKhB-HU*&h)S;-P0@fJC2=&!q7$$#`} zhLuRvFn#iBz6c1Mh?UWN7|6xR*SQX4`>&CkOM4h6Rd^igD^041ofWvCNj%cbeJ;YB znXoF?b34mv5-Ar|;3u+gA6z<{y@@&`sOTolbRT=La~;~v^pw2BKGP2#B{)pYYlMQ( zc3U^z9@YUrjTlW`D&z}hq6WX`708JOFB_~@=l;A98#<`?Vz;wi+pAO4*kRYN!ntP8 zx9tKxM&D$y?axFySx# zMZLF1x2{dU?bR2a0fw6RF=2MD6z*^WUXC{2R=!_1I}~?lNV}XckX~PLcP!XLFj!@0NgNXYS`JDd&&02Xe~OU$#!5 zmu49-{>^9dp|~ig2hJZ^Ie+-U$;kJT5IDR?{Wn+J^ER_?_>zAS4~%2~lq|kqd~rH} zqF$L0&cO;UIWx7pR;TI3Xkb$w<#SE;3z)!vD@fj8TP!k9(7pkq6OOSQec^nvkpfWG z%*s6RC*lqnZt9KV{VW(bf$tCg=b%UG#>qEWt1nZ~AN9tjJH<-4?m7c1(QJU9eH8Yk z=NZk>@;#>L*JDS($ZM`62q(iE1ZyhWw7} zNU#xlmwzz-P$PUrL9L?Kw1qzr>bD_^VXka?h&Z#jEDV_S@A&YyBpyk(6HzyA6`GNb zXCR<4EtWY7<&{GzH9BAA?VYAJe|`}4WjCvt;le#sFj9X)t*ZDW7pac2465dwQ3R)a z1{}LbIfu%L8H9~Rwe#v8Z;X2e;JtI0?EAa~m;$offHKNyG>JgGgoTfBwNe zG+fo65fF1a(&MDvns4kfnTXZ8nZ$VW4ai2W*Zc}O9+;+xKePtM#PL;jUrCB3=3fj- zXPWLl%e!?D7x67_M#rSR|15OKG1yQ0`1bLs9`1AA^L9-thgYl{SkIRoTF#O&3bY#} zP-`l$*ZMCEKRGiK{Kb;}=hMt9gZ`UH5#Yo2y-LG$evQf*i{(=2~et$pmRkK63$&W0+t6v8dZQH_P%m5sHElRM>uCD05dAMCESFu;4&gX^Rjoo0n zG>7hgE~D+u4&Hph#5;d&Q(AvMk7Z`=MC2%w_yh;< zMD>&2lk%Ggy4N;mr%xfIazk=8Mi8D|I~81eeOOARgP8QZU5~_DMMNJKeY)bIEoIt> z3Bfna><+7ZfuK5D74@i349VX5zn7H3GU^jdtDZ4rEZuMB9Z!^vf~|^DKCOgl8W6Ly z!L{|0)|sfq2W9DcdP`ogtI3vXwY3#D!{QSxI?b!YwC5%vG}DGdKYwN4vhm=LGR1@|2`ABU4<01@3*^Ryg@cJPW=eH`1LNdp<(K28`nF$AAP1=;ZCjyNv1+ z;^_W|Yy0#3ex5`H(xMz3#LSC<1OTif6sLxvw_zMojezC6xO>rNB@pg3d?P3B3DbQN z7D>2ruh?c5W{*W%n=)bK{d5~c-OT}4SH*<-OsXH)Fox142ddYs9-LQw{>t|C8WUos zBG2>aLIdB6o(4BWXF9h-{xgwP!jD}kr8XbSYyt{8`zT#9>N%=#yPp1!D5uKMS_RE41?t>Dv2Q|z z>}QD~Lflx`1*rVwA@AJRD=~FI`6&8Dy=%yq@%Mhx&@Hgva)wAow+Y$xo#EVd47h;c zye1X7y*Y_6@}3bV;CIU6xXXQdL(vXx>0rIHat5AK_!Fuk9QN%yqWsLvpQ%fgU+P;{ zv?9_j>fkD_tTY*jCj-9o-l$Xq^r8bUN3qa3x1h+5?#75@Rj%~4%?pXeE+33QL9Hqyvj3o5X#kF&K{4Pk%(5)OT- zq9EusEAmt*5vWq(3TT@L6hrNFsnaSlS_`?;Fy-`ngFda;(N@DXR<;XYk?XlK5724z znNk#zI5{%85UL!U9B0Aq>+JjFu#}X-HiXaKKlqzK?cO$DxvBY z5osv_Ge<9(?=gRY!YG`;^!0q{qiD*C)rb&6G3`Q=mXrKLA_^JQ0!TxHu$E8`flCmt{#)P50qeZ}sLM?Ux8pM4bBJv;#>q#^~-gdlz{ z9!lu2_73o9mb%Hsqhk^rJgAhQu9<_)}t*VO`$EA zt0p9>`(BqgR^ixuV?f@MR}cKw6&pM1OmRa;*4dWu7hfwEfLGf0qu(vmKe1>Q| zDix{3Q>(nWAUPCmQ9i`2WMi$|XI_3UZX(Aj@E7AIkFrsB2Ht8`!c&zk%jwMd8=HPLo5n*5TyA!nE zwf~jqjAAJgxI1LJzM-AyS$^C-Gt*J|WED>ejWRfHh{Kz>qH4-|-TsUB{_CYRw3x`< ziWta(`fS!CgZ*-JETf%5Oy`6)t7EZIz#<*-J`8zKVK{r;>tGq|JKG=u+(vI7M-Wol z4;B6#BpGk|kkPdwbw5x4-Q;6gtc}ls`-YFwVN8S)f35Pe#jlQ^)DCiWVP|}r2K(7efPr}cT3%|tN%U?WroMBSm?%hEOU*DLSViVG&Layg8GC?KUWQRK0ikQ zJ=(K1qtIyRg;wmQ#3jSsUsxYD>d-F}lL5$;8}dda2cDYJz~CNka_OE+1lh2FxCnd_ z!Hp6Y>hQGXlHCWG<%78Q_uTh?Dq*9jcE0O~ZSbaZxjtg(}OM3?@g2r z>1uvHKK*(GR(N{Se*A_}f`1r9V*ARZC0f0uY6W{Pl2pg-&*XbjpwCTugZnfQJmH*r zC6A$3AEA9MY5+TX-R@4=X8Z#1bsRLhmcq z#r#K6kgVi}wH%Sx%EHEgp17Md=kE3rVF?bF^R$)>%xG%amRGFdi)!Vh)(<$OY0Zt- z<)?uo%LmO5IMSOfNT`UB4^s2-laFRUH4)-j7wu3?4I{NjC?;zY@Ns@;oVrWbX}f`o zwy}G#?TxaMl!Q#ZoDwNNjxh9`Oe>UK6CVEJrSOi-x^6Z5qi=P^VE)TvfPshmMW^yz{S;pKm z8R0Yu0j9TX$4Q08Mojm$r&@&P1Hx$gZ*H<_U`T#H?14%C<1N@6IOgOsMP}w4x8{Nn zSme1wl(p<@sVj&3&@ps73%pWqcd-q2Lefr)#Wgz<94XjD%eQ3{vZOLDF9Ux6z`71= zev&%t9)iw^KkuFlOLr7+I(>h$Z{*Kd@l*IaaeaW+<7tCgCgN-VjKn!5Ez$kSnx0=X zUvtwAniw%wViKGM5AP=C&$op5ug%H`U)e7((09Nc{B>iL>yoF}*WW8OF$;95wU5n0 zZxtV=W>j^Ay|&LyWOa#r?N3U}61W*2m;M34qrSlPYlZwPBr}R?k)Uk4c~a;3wa0Cq zur6hgSx~#LS)#~TMF^^@&C0#1`zxkD>Do2gW7xMbpbI+4U8c?-+^H>&PVVtCxGy$q z!;*q7?DY>BIkA`F@3C5ApgtrL;|m4ccWGOl6>N~z)1VOdn%A;4+h*@Rt$i<~zt z2uX#ow4bAQSK{xka*q=8P@0M$)}55>zhc<1#Xn#xyK)!7aV$T(JF4XRTjxjLDy!aG z(w6U4Mm?yt^u4mBEj=)+@FzWCMtk> zXQuwY!El`-h1imXQHD3#fc_?s;u;_299UCi(?UYwE2kAP30Db^f8EuM=Be2m+7-%K zguWx}k^qbX_wNz!H4(`%qwYz+epDMh@5no``sJt^vB>J?zrCVwIp(WYG5!PoR@df6 zP?nH(&0v*<`puuVgPWBWiotU%Ba`CcvsZMNZ@=E6pq2Hb601n}+j>D%9RL`p2&f5u zHo8@?zlH8#y6ksnpU#QhO53afT|?}VA}xr|E%}scqa5W) z+AA?UsKD3xE+a)4w#B;0^036zW2NDg#6Sf)?I@!h(~^haqS2rUlJP4l?0mvbRL*>s z2y`1&sZDzLO#fRQuQ69*q`VAcl>Mf_Y`564#cxjS8@-Pt&ok~|7;a)BqCd9sPdf$@ z?awvxQvnyZU-v4bMU}u#{hP7BItfMDfj&^PC#6omy#T?aZv&NQ#Y2K?k;`U)O@TC8(?j7)Q2UbB( zC(3;_b<3vmV*j5v4`PAdY<>h|{a(}{aQW|vH~(AD=Q&61Ioic-4g)6o7SH7>BvPm7!RyADc)}4+UvO5 zC>Xz@QK08;MS9A;LOJU^fnoj6_MX+2F3D{F_N(X@WAZg)`89r`FhoxHW0{bWrp2QM z`e(-LEK^m)TCtv0!LB=8ejz1PzMY!0IFa$We+$t1!aCkjGLjLe^M7*;R}Y}-qKy@= zEu~|+%f9<4E|N}fJaawgh%Uq{oHTOWEgHQhX25fGKg_%AfaVvmMXm5wVqhMs2zW&)$cPWq*Acu2gWow zZ~eMrhN-ip!^f@E16fGObBwCHsNvdbQ)F*5nRHI9qJ_KsQMV86wx7JC;yZ}*`t<{m zf?G_Neyy5^a9f_BQRDfEC9*p06uZl~p^n}^QI%AKbVr8xB$1&GJ9?UJe%m2QCY{bCK zdmcHIAnoeq60Cl*eMXLMCRS(O0rmgwk;9aP-uLV^459mXBtM#mYlk+_UyypKt1*T- zTl`X^MWXX>f^7!N>l#kl>YifglqsC68uC1nfWijISDx+CIDc-M-h9ce>ms>*9O^?0 z`=fOY`-RyQi8!E9o#5HP$W}TGCRLPh2ptoVGZwKNcAc&5U)fXl4$r)9wrS7CYXB(i9ucVV^#`3tj={*`jIB0XDFu zz5Wi?6pVxw{acEbG}m`Ew=~ABbllMTGPse&V%3cFI^Hc!hYpgD3_WhPn-{%m@0zvbmj&qpQWZHzXAl02?S6_bw%^czLbg2vcN3zzIg zclG;vJ&918Gt;x$tqm$UzV9H0=0<0pF4w_^02k(CxqFyqjB@4;Yytbx-8W#$-bX%< zL17s11|F8pwDaryauoMA>y7ZRR_fhZfGv9PJ*Pm5f_u(-g#XXD3kT(bA93OrlmUKC z3#q`jV9Ex^I6$uLf~qx-JMD7UcCXb6h&fruiyZfxK&=P|pbU-Mu`h4kkmI=Sm)}@) z(I5+e%mwX;@NEhyW73v?kC9FW>O{Pu6v6F+vP2!wIO^`S&vYQE066z9?Z^=2!BYfe z^j^imVVBgpe-q|uE3YhHBPwJ+C110_R}D(;SP` z%-;vYowl|3-}Eu{P0BQL4y?s85U~Bw%ev}JLS*eCS_vQ3^J`6TdosgbnoL>T(E4E3 zyZ$fGh>@wH#!x0^_lZDc$ymDj4a4DT0; z8P4y3WXnm1@|N_#hgsa@Y6f^QVq~AV%8{PO9Z#I!WS4mG>2n?~%26mvP&{y9`3zZ> zQ$M0;C;2nWdBfZHqCI`2`r`^F&q*yLuYMGjA!k|Qc`wV5^0lmclL%P39|btvL;?|K zrp!BnGr4tp@332+<7;XOU%q4Yd!AKG(YKFlnj{Pet4+`qU3v)iK@QMEzy0~`Q$t6B zt~BrJq-OA>{D(~rHqSSV7vm9qK@O@|OLlkuf@6;nk)o-Vv6R`aeadLx29zg|9km;- zqhTQKhep$%{H@NiSjz zuaDgd?x4#ie_yc3)7H(cJMqB5_(kg{-8PD!A16AEWZr7#=0%5@3HJe=B1acaMoE_t zr^C0LvoH3gh#c$T6-Yaq?x8M$D5*v{1ahq{uSB}jjsM-5pg6se*=MhL5-VN&vUct3 zJY5v??CbXnAP7P*IZyEO*$30V#K z^CVZxjB}bp5{@4d!Gc33x|R`%NcllrnHv~t*Zb7MLFpIpB$dTB*e}bLMC6TS%CXPx z=V#yEW3?cRZfI27Uft#RM9z;qrM#57Tdy2h%}D!HuN7EcQniW;fm$FOmgC!xLQhqo zFS$K~9vUk=PN!!p$JXZQ;#bA2oD$*$oxvELf&~4l3&jS!%J7Vd7inW|tIR{o9XE|5E9Bk3(Wvwsi!}(>p_X^3HzH&7p67cNU zyrU!7L4Vt))elz0J?kAzJf3spvKp8|43z#vv|1%oBZ7!3k-e`n_ka5fYOEHa~}-4gF6~Fax+0i z=P>17g=>p;1iX-VE>jrCCnaR0?f^>SQdX!cwsqPYZ^QnJwZgA9y@rD427$xnzt`?y zLg1C6CF{Qpgj1+bm8Y2vbg)_=K#ada?~UV!C?;5@0z~i*-W=d+td(VGjDBST&{}-? zR?D7UBGWAKx3XO1i^djw)$ZworsMR&YW>I4e`l!i>6=Vv5YWQx*IcsFJ7i%NG6lE> zj<3*49+dlO{K{!0d*2wZ?(*@Ns0L_+Owx|HOM3oAX{M9)3;X*PiKcm(J=GBCO-m`! z4GnGx^^t~*1lGVm7adBvR~f)gWpmve0{nAL)1UslbBn1u3C`YM`7`(+^`_U(Ein<2 z|2fs%d#UI=FX+N8Y0SN3geQ zLv23@C_X|%oVhm6Lee00alNNDCnsVr$8Jks_Bm|)!eDAPsc8IwbJw*&?%=9Wz|4ZZ zNQ+_fnn)vJ)1KOVI9ysBfluoCUl#|v3g ztcNkBX?2l#E|268P?!+azNl*xD>Cs^h}mp@qm~@(c77;cKszwmcjVv?vz*(R5T2>3 ziYZGaT5a@4^2e491mWW6_ADsfLM4n7SAsfQ9v2Q_zsH(>S|^dO<^41i@Zr@~de`L0 zR8;7vDV;pkRu69|Uy>2~Ddm!6l9Iw-yGEGTMP=Bp#s1_k^ZT5GI~yn$P4VYsS5&{) z-=eej^9mzX&Wv`T;<{u@UpOMil_u)lD+fLXfOEpb5^%`WBR)BZ!0xJfK~hR(de>;( zabF0&4&97B-M<((OIkB1;5Zu^Y|C#X`x=~CB7Umzq`gmPr=5Ejr>HiW30@I<9Cvg1 z`A^Y$zbrY3h!liD{5#ZNj8DwM<|^QZ6DXyMai>{|;%ghjuC@lOo|~Aq6_LAy6Y%UJ z@tNm+Js+wKkP9EqwlmC?xf&;b!~1 zJ1<2wYT3J+{&fgHMs!RH=T#78$vkz=`>R=S)7o)G1jtVnAFtn*6j6yQ+`(qBVw9P( zI0$BfoPLt!<|PsOzs*Jun(jAne^{jcd-;E(Dtp^A7$tiec$1f9jaAE4*H--T*^Z&l z*P`vJwCQF%Fq+)yCb)T@c`)dGXoF!F7Py-;zjg>roQJUbuRmoXxv$tO4mYF_ig zBR5~g{HKlh^mmAEAiC|+b{`>%i}wWXS(s*0U5^F5({HM`V7JK3lb!>YSbhiI69!2O zuVHwFT%(ix6T?eC3ZMnQCzUVH4iONp#xlwVZbCZjOqyrmU;izjcX#`Q%Dfd#fA~8q z*{M+v{62nC6WEpZb-mlb?5q5uD8^^{<#W<*XDeEK|FrP^POqBMV7@6(1Pcr73&HU1 zytuRZko$a(0$1?UYD<12-IWD&k&6%sFnh8eVR8FhpZ6;b7IG3ABlWl= zyUc?R51%xU`zR@y4yOBJ*=Sre%~VW)a6^e>wHe4BPkxMevwysS6M}T4ar5gi=Dc9q zuO3V0?*{T*0teIW=iC^rw@C|q`gkQuo2nkho#khz6mTR0+F=2KBZt5 zpgiwIUzD=2;8Gf}R#{F#D1>z^z_8PAd@}tvG?(BT+mgQ&S>)GuYJnER5+kj>rt3|& zN7_?^L~vn&Mp_La^}5s7TWZL>SNr{O;v-pa9=ZI36ZcH`ql{!k$)EOG{W3C6yYft; z+k(B$9qfDGbq@xEPikuCUt4zhlUD8b{W=eSbZC#d|K27~K=E=veszZ5=+>3xg3ZCg zD~PH_B8g_B9_t=v_U`IKrALG3y1eZuXx;tw;=YdE+!tcGbe3DpDEF4cmtKe!KY#X` z7Pcw=6_5ur~%DwjZ^#I>NU#A#)UO4I<(Z{tCsGucE zMBvA_Uy&9B6*Z;pyXxRsD#)IOXjVTZgY+`x9`P?ChGuNq^M+GI2L4pcGsk9>NwECR z9m;G7W&RZf*Txxq@jojXP9AHl(DRhD&!ExZPZV^g1OrPNeDnlq9rR;nch_75U6)mZIaTo4(?AG>myr zx^R;C?CY#|+MX(Pm3Rk<&}}eX`WwlQI~tzJ>0YNzlF@)QbklZ6+MURKlrE_^)aaX0 z0~gyiwNMX3%Ca>9YX~V2_7?w}rlm-Ey9&zc882Rm^7|iW5GO07DGM5;{4P7Y@_=S6 zWff?=`Y0!H=dl5qgm#LlR^wiwbSk{^U7PF%-ymSlK|cU$*(ZAO>!(ns z&nnyqHs2uZ33uXF{N|oIIzf(EUa6_bGx8QWg?QC+W6_86um^V9$vdu|?D!Z_?r}wa z4V~h>=kS^@{&vIb3msbZhekZJAWrh(2v&+WZTXvxCM`$J*x-cqO1DN$Z|-VTqr9R= ztfy1#$405T(J+?$v|l9Ma&z9&0_)+PTii0|gYJ)BE=)n>Bdd}$ZoYUP5MRkHKzxLK zfRtll=z5rnCLI$0Cao&it7g0#dZC(ddvdn-GA?N%ULhHmH#o%x3Q4k)KAAaK*NtcA zY>V6MX7Ll%)8pF zH_PLuvWdY_g5p>20BIRqjdjkKcffN5w7U`mOV! z>1_I;J?Y*AT%9)KJXmvw^Sl1Tc=MEKCWQI9{<%6{4zECsm_{N}n)s>Amm$0D5*q%vpL5hH_} zOaNuOt~~0Px$U=Xha*e}G-r%QgL1C`d5`CJ(?ZG)cBnAZkapJ`-(S*};Z|*cU1v4G z^)u^l!7Y@z8|wu9K&dMwGy4?bh*8n#jv1`mSj)`YIcrN!cmCZM#!me+Gg=3_iL@SU z-;yq=u^%^OTQV-_mYsprZcA>!um6f-V3g-yHi6*zs+p|^$|JyC(soNUk75Plx5${X znrSZ#2C#D!ZN1$GcH~?0DAk|T>PqO-;B~xiPQqMD`Kz4OoIxZQg7P_^%~EuSCl-;~ z!)^)=ZH3;F4%y!h7#_2Up1~J+(yw8HTVN#!oeAZuh26G}pe1&4le*fS_YVMzf8%pP z?avG?#G=G^NZijkJ{$DO0^zBam75l`88-@+hCC8~sNv}YSg=e|41?ttyJwvUuvtY+ zGl=)BSDkYFqu@yuW zs4y>l%3r1JQKK=0lt+Pwy?|4mpxEzccw2?>r%*2ITt|wZbA7lj2aJzjE{-qm$6sh; zRW_v#F7BIoWPHZ*WVs)tPu{egT^O)1zqMUH*IURm*e3ffO#_cw2qV{28hp@Zf`-c^ zKi2HAkp8L5Ty}Uc8F8?G-$1OejQ!~y^7;v>m9aZ5^4x7pe^VW~Wl0Y3%MF>2-^_^j zR(!3Tb~TkV9p9!cp0Qz1CqabWj@};kWlzy5P$iD9PlqB&Qs~w*+U>C$56IF71 zXS#D4YD-g}2gl(V`ZKX_P>nk>Fw-`|;`w-{A@1k=o(Z#(ow5_>$3Z!!bT0!5%ABIA0O1t+T9-W zV?rPsUYnFFjqmwStGH&*Fsu8pw!x}xW(Sx0lB*VjlhGv-nMSt5+1Xy{5AdeQ;pR{D zWfxj}7GO)+vGXckhY(uMa~u_^&zz*v-`VhVk{U+&jSfTV$^3DaQwqP^WUnqA1zc%>#dU|hX8k71B7x45Zoa=(GoKpd3$lt=!TA5G~ zx6I0p{$rUSo9=vI@j8VuiV)UuGFmog|<8)%mWIaj8mw9J}mBh8{EEaCUCG0o)&!PV-G;C<(XdUjXV+I zX%=nk&Vh$64l;3w$MjmUPa}mTwaC0*C)JH^Ttc=7lt&WBvn=oqzysSoOct^n!kBDs z7S`pN??~5C#-EwDc~abARYlI?KCZCkc)#G}KXKJJE4>bKUgHJ8BrC#KBb3vw05E?_t?+P~~w|aEm+`qJaq`!kQC<*b|T=iz{v%@+k1m)#9qOySAv4Vr48ZMF`{ zB6f(TzagJIcvP;qzd5UX@#=ph9qjzXBe(+#DGv@JdwKVa-`T|E9ImvUwCM%j{K2*a zr0Wh?;T(W`8ym{e*;m;uO% zT6pzg#-1e^p#S4k)#ex=LUyw$8_++Vu365tpw@3QL6qV<&@y_-jUAjHz$Pp-!Nsj2 zuAMgI_JND*Ii(K6ws)$fCUf3_*AF@bd0d6+J6b}}{UJSK&K%E_((wq?nq|OmkO#hS z!Do*&Qazn1>m{X^^cw1K6}cOpR}}2<{3F(N~)S$}g~YPLp?z zABjv#7#5!x1RMF(m7xrXaH?Zjg7vMML_Z-Z>?5gj@SBJViv1J_y7joUFLh#l<1e*{ z9Hd(dp?z~Ic9w}Fqgwtz`?GoJBDh_nw7knF96M9`C5%Xm2u=FGr<-78*YR3H+e%=F~f#($P7RMq{rmjuPTgL(xYCt2>6H0S={ITCe2 z_DV)Fpn{p>%j?15c3>{}K_;yBQ<-dVxguX^DLze{18bf6%jBqV1AO|FgI?VIF~rzF zu!d5z&EmMT%0_>IwdB0p5pTcdGZjEl1nblK+q%D1Zg&8+^705`7sl7Pf&Dsy7PJ zFB2+3?4=Sxkys?wOFcr`n(O@4V7rOYIO~m)JfjT=g1SKo#_rA4#_StS=Td4?<=_pH z1$mWWj-pCC&uq@~_NXOufykg8sv+^CCRVwDz{w+f?xRv!UepuN&`h%UpiQ-msKic0+U@VPYWu9;sN27a9FFKf+XJb9m8O`} zw@t;fAhC7ep3K~cpF-$)={`UYEQqB7lWJg*F>u8HzAN;7^7V;TXjl3pyo0PeUw@oJ zISWE4wKiaTV}*5IVvIugF6r;Xg* z%Lh|*Gr-6c<})SUdr1BHD6%q6%kX47ipiw}WXdf?8apq@mvM3TF%J_p>tYi1>4}e7 zDv(vORg7fEX!iHFC8vlZ`%h5tL}ZHZx1$t9`+@#FZ~fn)zs4R{7xz(pRC1qqn?``` z8xUuDr-8MDjCeh2M}SIm^@g{3g~M%=ZkwxkV0UMbGV1I5KxPV@Y?0(3FnYvguZFvx z-7^R3v7N+ClS;#J&;Y&xV%YeXz=%<3_c=Gdm-%4;F8|c+EZ_twa!DeM`hz=>uaC5a z)J0R)5H>niKUanBg?UDpPehGhnGY&9IV+`9H$Z8h@Dj#xmA@|W)R%jEawri0n8w@F zxnIK4GU9J{(PsXWS5ytV`6ZWLgw*M~Xmh{=`df+gdZqCvT%@+%El=5J1Uqa1`^B?k z3up@63>apA@k~~DaFc89VOyKtSY0y`3&$qgYs~1aWv(g5kro4;N(t{| zal~#@3hV0xrg}vARb2%)CT>7-QYjZ_C|!8aDxtN|=!+p86m@SQ_&4K2Dh%#=-mzzemZH;2A*Mk?fhHAO#6^vf3j9~BF^XqBpDvRPO^x?KsTU<$oAAh=zxuk!luQGQ4o zi!2F}LamR_ZFjs)?S~txqW@Vmyaj3ZyG$ZLu=Pjl{zCgF61#Ip!leT69d&0$FPVG?1whz2^=ehF?P@zOo;6iu%{ojJ|BDyM^xr!Se8;9@GD0iqSgsY)*3v7vEY-DB`rxUHBQN_%Q;{0 zPhtp_wgR0p!u@oH0umxB;d_V+B|Pj8W8xyZ=Y_AHI^F@#bTdAQP?A`-C2Eh< zX^!zPj~AW*g6&}abC~$Y3=m*o-1-OjLhUvI5MKTrlgIbI8^nBC zQ8(qeVtHv(-uYcm#xLgrq)!gSusV1TmB8|6(2&hf{j1~TCM!7FqVzB$-o6_+;n-fS z$%U{B_m~=!G~VY$d6}30L+Yb2R)y-)0Q>RN)bd=4AOrCI88nV5-GDP4R|Y%l8SQ~7 zi7b9bFkwgvFurHNWQ{RP1v1K;{yuuY<97{N%7#hjsQiP=!WVBIojvM&BC;$Ah`;H- z9NcIvyq?93iWG~TGYsou;o_rkY;wk?us^K_tS=^18Ly++bP+Ei9evDbi;?!rn$RUy4i$^qU<74KIw^iW*XSD z&VKdE~Codnu1)Cm`L*wnNeKCLyIze8#OHem0>kdmho!S-i53Z*Hu_7zOAJ$>rr##rC zIONJrI#PJX`KE?{9c=bJIERqVSBdmbmYQH&{Y)@0jfIGGL#|gM6%~b_tQ;HwYGI0- zygXdp6TzMr-uotd6sUAf@nu2hbo7YT^=s!5nhO1}t&gvl7fv)4}12B#*#SdRXke zp-=;Q7qN&|b!?RfPNOqXi=g))aM=fFln{?xMwHV?Z!V-v%s;Q1hL$e9N6f4kw4Y|9 zO_z$vgXn?)@*YH7($|Mp-)q!Hb~NMYE*$_QaLsjCVSBS7{v9}-%SQhOqaBAjy zB;=MmSfB6)Z)!iiz1h1V`4ISta=)1Rv)2d6r>nEoZ=;j<7VD;Wp4ORkW5dwCwe43qA#oMT~m7tMW=&~J!bCFf~@F@l&L#h?(I z&|!7I2QuX*HiHZO~pQpzqKN0KG`C;(ZD&ZBnzZ5P1W;KU1xwC zhdBFSNpLhYp1OHb|Sm{8%v`U@BKbig#u4Y2@*DH z{~9;1(4WuHCwrz;s}%XHh~903Cf`r^@a*X;cdDwM zs1+>xk%_`*wtJd_Wece9CWI$}>$jK!iKedNzX%q1=?R_ArE^tHiiM6QO2i|Hnv(|U z4knPVe%9S?&61+C$So>fremObdYAAUf>_!9HG@h%YR_XMOYm2KIs8n?BQxJb|2gCG z{%nErkFfXGYe!E_sX>XnmTV1t<(&EguP2lY%rS*a0Uhcb)Ut( zf@zFDKu&xP8JEBb&9Bj9cwQP(g&`(6QbNOh9#MCqx%UAl40b$6D~`llBAETnI^4i# zTED|fJb~z!qyurs^^qHP_gNR`U8mD1<}KTk^xT!p$+&+|R-$N}vm>K;hayI3$2TE-%lGF~u3)|5ic#F(@f-Qm9M2vk zMbWcQ3zD-U#{^@UC4bevnEbNH{-0m#@H@LJUwU{vios;j&JL7n_$lsbg@NaU@zaRI z>ds%RiK|Zms~*X}_|*^EvQD<#qhB}0!EesQ4*`0(j9IL}T9WA@eiT5DWWW|kEEY-V zXukNRgO~A&;@rm!DjIpuF%7)IN;&f(gTRk0cyVJTe>E5ScVF8D0OFNRjW7b^fEy|} zZQn|I5c75uh$R2ZgggKIEtH0Le8~f-uyk_;Y#|wMYIX#!A=hF^MyRMHC(s3j#l9#% zJ@MDS>oS2SxdBKmz_r{yA-Oh#H}ZnX`j_N93q`D6AQ#KRia8;4X z@wrsanI;8)=KQpX>uOK)mgQ#~?vRG5x#4Nj8-Z`jv&T>L5GeaHb7{VC(HxZ(?%3JY z@V_|o-Cgw}MGcHi)zuyRrQ?RogN+&NoWbmH z$x1Pwo7fOATn2%!sZkLi=e)k;Jkj~iarM})4$*Hdg6s*sYfkiRS&^79Q(%)cGih6T z0&9sWij!3Tfp}NPacYP@iAm6Q^xLVNo|j#RkJ5fV=2LpRE6>oH(#rh;KAcX{jQ!2W zy8q`M$GKO@&7Bnbb@R8Hm)kDy?SZJ}Jlm6AuyyMH4EnQ-b`h@YF|nhV)G8iZK^4#U zrC*Veq``8`qEhZJ6nULqI*GYkScJp0Tjp>f4=93Oy_P<%l}RHix>tcye&JSpksqN) zsbvo-ng&>0p1=B{7fOE|R1JzRD$I1-=T{3y3C1{CiogHAznj>*>-$2{^#A_uXf8T# z1XttpOPQCYb_HrwW^$cNBz3CSY!HISn~*L)tlF(EpUR!!Y&hp1v*kqOg*l51TI_tA zQ#llN@JWEf&#e8tx~C%u?zUS-)76IG5A2+N#LHs{QmOOuP>ot+yuu;-@=996MAx__ zl$e+i6ULDE=OiSiX*zY4y(lbgA5Y?wNSS+xLAsTj^>5s^pa5Z}N6xiKJxOHkX@TPs0NLRX)3Pw#-lYBy}BpDP`-{!@$UbwyqQsZOyisB zc~VpRxmDV!7Tf=n{n?-%JeTZM-wGGtCSUge5d#W=`!)eTX4P(u@Gdm2;<287>^g4s#)o)vFo_?vC$6ycV89ONU}Vjn8};~ zFK9RmUNCJV-rmXPzy19Q+}~~GsJ=bQuhezq{s8i9d!MO_pAV-cD>hr7d?)l7hgX`} ziM8}m*Qm=p1SXhjHX~AZ_Wt^gjBkpY5$Tf`4#r)?#jgs#vLxJ=G#gK*XbmG$KGn0-E)5@rTpw`v$zi3(A*sSvYU&8tG_>gmMK1*Dk`En{8^|igx*SmP7}uo zQzpUJR(dczm5f@l8&a>aR#AC_${)LL*hxc}uy;g=ev_!m?`^O1wQ&C|m~c-xR)J2m zg7Ao;7ZL!@myy2(D!){ycTu_yv9ITa+ZSPoy6|pQ^de~W@Y1jHD-$@hQFJ#mX+_v zajly*B4r57rJZxuj@B+Nvkz_Qu1hxHZqAb_$#6numWp{IZFO>jk)W*ATpq>5>fy|HREa^S9t=rbnXBtzDix zUy-+5?%p;V^V{bx3_X6$`>;*SQR@1|RN?0PVGuj>p#e{fw8MRy@YC_rC_E$R23!mG zwa@Qs#LQOe~_}iplw7N%cwj2cAu(+v-{1Yi}=mPct`_M^OvT-ELVi zWy`Q^tdps^W%X5;jUA@oI=x~IEsoGQE%XOFqqe`NL@GH>W`#@w&Ix`vI?f-~@%ZkX zKl9?Scj^2K_%l@Nmk%#dXwuJ0PXq_rBt_97FJ?F*g)B)d&l4w}FBS*2{K~1X?i-y2 zk*!el)k=_9yFDsa_5E*rY#;UOV!+Ru#WjqUIh>qHNiZhO@6h_W8o~KIY?GL=w}`|? zm_Uf6O#}UOe`@AFDc?-kx8Qrt#tyA(-+RYBo3S;s`Lx= zFD2})kNRaC*JCIS^4BLQdx}##bv^~;UGs6=Mu86&?qmmk>lBUf z^#eu^1S@>k04@u3Yo}j}EsyqIflc1II8^5MMDV&U0>!la7oS7};}&Qj`P%s8I^;{{CcW!|d4~{2skhb7;I&rowwlc#K0Blhw{Y#M!p9r}q0NZR-(Q zfFqy|#tQH+0`ZI)DmDOYz3-WL*eG;LBzU#$1X(h})xD#Exx;H~vw*o2yXn{wK*JYk zw~jzG{BI9YRJBF+3x7g>_<~gC57ghc+jup)ntP+V4x_8<=j~q{i_Wapq!i9JbI{OS z=k8r2!|b2&<{D0f9N2A}v;yUv?~iK@P1;sjZs|z=&+xUbVP_@xTPHE2h*yQx6XRVN zYgSRgs$`@PQAh!5!FlU;ZaLxme;*$j*+R>Mllo+jmHd|qV8=oG;s|%*2 z``>6Nc{n^wN;`Bzg!3wqvq~Ejj_3vY?^fx@Dn@YK$(;Xjuwi`kp`zdF8%T~E%S3(S zfVKKA{ zJ&JIC*2AK%4#Ng&_geuxy6(yPT;$$D~nSe zE9)xj9m~qWk*nsyxt=ptRcU|8WqK{BvUiN?&dPhSED~$}XEZ@k0=N9UoXJ@}f+0?W zQD@x|W@&Dikg8CfI%>KD1>y1PdKvNV=1*{ z0<|4kCcR z$)K~8cbsIv*bpe#uTlCz-v{{+OjVs;uF8A=k+(qj9?GqmlOaGwxX6u>&`y|N3$qmx zox;*{;z4FEx`XC*`t5AcN}A7RV>Vp&w4i5?{HYX)$rLyNp9QQqK`P#JFV|QjQFS~A zm9zIffZOdEjG;rQ4=NbZI>GcLN-JTliQBf zuvd*kN$$n zzPAuA>TGKj-RNm?;8enVdED8iXq4e*?nkLjRBptra_mUREbFtYZJ2<_gIxQ!l@|t; zSKRAI2u&p|P5+Q`)Y1qtVEV8GM1Myek~U;My~)B*&(h@l+G_u8rTe(pi}C3KeRur0 z`dqVg`j4y19co9b+mdgSSeWckHq##c=-=!ob;Ele1^rGNm*131F(jitx4U;o+xEc-Nd<{3vn>DULYB!GIQbDBq>TD(+35Y{CW> zXA>x#2jc$6JH-WnY9b+c_9<|34S}6(JKOnRSD~!_!maGMcd}25-{!rDJyu?I$8NPs z!}82)auhU;d0b8yQbDM8>J+MLv~sUILa2;FV9&cJYgCt-==)oBHb~Rg{pZfFk}wuVz_hi0K3JQKH=@XDMkPO_BtB(nzdI( zc$wIUkH`v0R@tuCTQCRby z=n}`OZYbU>oaGO9G_Pmy_*=@elbisJ+|XWm!CI~_QoA5nimzNQK$DdDzV-GgMrS?d z6y)_N6vT$|PY^z5s~)EjO+gjJ^m8aBs-7;c^Ca6XN&YBVH}lIzyNo66qklPq5&~h_zI<66g zz?yR$m7S_V`EI30=YLb;RPfYru}@9tXFq_PNvyuh1&-&g`_6iS1%DL}8*F}0{8Gkp z{UGo!?>cESbLgAy&&R1a2#{PHv4SQhy%bfoQ=94nzc-{d3D2cP(1T_7^C%}80EAQn zxC4S@Pe~j$sqPz|0Aj$-vy5c#ss&Tlx3t*=pl(-gaXfJ8FiUWPue~-pm=<@%7rHzy z?LzaeM7gc+j?4J0#d5(Q_KR>KDbqjF>gUb&&W4u{5G}V?Ox0qiG4z2Ny#5b!U{Y20 z2XJKV{`F%Pcs+~o_zo@yLGeGi0p#vTJRF!!mEh7+4Mz~5fPb}4Gr7O5wS^c(Bp%$< zT6-(pIsk6S>-bGm%d6cnY+g_>+*7pm>Jt2u1AhDS6ws7#!gmoh=LKHx2oLAwEes3$Gi@~Zt;{3bGbQ%BGw{)36I_uNc> z%54A=OP+)G+2l=`)>|yt{5Y#%t&}^2?~45psMc_KWo zU<;(|X5RAWDQ1t^^%Aj0ArPvrz!ns+)4l_m=UB9G$DO7ipc*`=44N%QH6J$nnu1ou zQnL}YuBV6cx*lLAp0rVNtcz%6_~Un}nD-{B9C6g9^9v7SUG09Xh%v{!`-|H&5g zUv|Xr0B_W{Cj$Mz-O03af5{FWtYutVqvcQ1ByZerq$3xXiypAI&)(2+3ng0{Q)oh- zR|a)@@p_(9Slu<~raijP3WT=oEQau%I3#7mUy~!+#oK$Nh@GQ}!cu?j`8P)NTUvDV z6y8wOjar?pF?C!`!7XRH9IOUUW~4Hm$}*ur!e{WG%8r#DDnfjEMx~}#>WXuz3wlMv z_dM1rY=UO<{gS%u%M={*Ppx4r9V(}B%pN|s@IB6eFz)ncfRJNwx2i`!3fXB1n*yROioE&X-?8}=wf%ibJV{gSq$qMeGr46pu1|0!pyGEp}dit{; zEV-ciUiPL`;7(~(Gz##l^w)xlgZ^N*5{K54@X0B&bpx3*WMUkvFJ^mRz6}50c93Ny zQ{PH_=^F!KDLbG*X6RDHSlaH+i87>Ok z&VSUS2rNLbBZGL@*CZETr3L2?ema^QD(Xep^&(kwi}-|yggBpzC5s3@NT{T6?Z5gI zzPy#k=!SHesg(_~tTzcF%q#wJa+Kv3t#^n8Hmsr<%(tmX{duP2FB`LG?h zCOQ6c>ei$7qpIl(y_IN}J;|4UWYazLaZ@^DYpt*G!=E$fktlh42;)DWV!E>mdg*hU zNlkb!nuRT9w@AiCT-Rwma4tE>4Y0egk5xw)0y_|4Vtst+gp%cfL_ zLy5(ghl?BW!yxIXjy)t%P{0MjJ1zzDHA0E~@AFUPg}nk**O9$?Z}*mt+)wn|iW5;d zKVcDps=cED^acD30zuz9t>3Ij$?p8mq_vH~o1rExqlyM4WI2YPh6DkRk4Mg!QPBQR zM$X);_fkJ1Dd~hOv-BoF=g5w|<+zZBA9o|~N{MsJ%24OyA|b-_&%WnuO=)7GhR)aF@htP-cqGtw(@`c_UC)0O0b|Cuboi(*E7x~4PeS(unD#N$E|Mrl!e+}n91<_zx0`YD~J$hZR4Xa@q8>0*Zp5Z&Ute%}Ia~Sv9 z&zz1&b4gnI|FbgHB2ArCTqvz;h#N2Q9`e-fbw*T})TIHKGawQ6#)7$3vNzAG0|$G5 zX*_TqaB3TXm{uT{MxiG+*%EkHskQ0A%4uO;itOpnO>aA3G<#;r`G*i-UqUV;3J!EU z+J4tCv^JTyeSMugHZ5cBErlj3qvSjApM;90s`AiYwg)))j`aQ3V><1T^Jku8j=Dm{ zZZBz5Y8YPO^PW`HbgVq;awnD)U66_6le#-o7>wQ73OVh1i|u1}18u}x?O1ngbY6)u zh^?X4plja>D%MO7s97^5Wh1trYgVbo=KAFFIK=1nB<4MBE;L(yXgGX)QAwc`!cO7N zVZJ`e!?*m@rgoBZKU z;G6dNS#%e65;A$`EL|&C!bc>ElF{m+&)vScxvH&}Ir}zy00T$uDb!a3V*?*-h3a154;fKXbL@E{!QlKnEvdGf9hn&xK zN#qT0nP<5?<>?+9>ek4L9D~VWSTraGG}T_M&U(g(72uA(9X5eK9`PmDT7B93B+7{7 z3p-1Wi{_;BV#V)7Wqy`T+&~#Y{(kw@5PR#imqn&iOvXHPgnQroAc1&<`g`k936xr> z$ydHAJ({Fiui*Dj@5U_`KRvWnmmv1&kLBy1q(2ccWO%T6Ysjh7OKj~@NTp#C*_?;E zRewXz63p;x|5dc;KXn%P=ykH1ud2s0m@m&8Oc|=@JQLn;G#EN#{K zfouetL+%&n^3cw5t;>?=>JHg8dE7y~GMr;g))+NjH`?MS9e4U2|KDFfjPS9VIPanD zag5wxw5shwAS;vBZVWk{Qm;%vQ9bGWV+1gJwyHt2oKFM@(NDs{e(5r_7)3G!;yvHm ztY%%g2Y~x|3t&sYf_Kdc3-nH?B~XWaw1C~ z`X1`KX8d>$=Owy!`NL5dKpV77=X-Sk1O$yUT^riHsmy9Fp3TCx{W*9=Nzr5VgMKACJ!8 z+W-7EBR}fr+xPB!;`F-E2P*wk$HGjl-xILwEQ&E7+F%pMXF^Jc*zYe{fdnWpzIN2i zzZY*iJO`pt1-ti8p-PGU2TtgKGl+D+iPpX{7LK_D5&)Owao)b`y0ix)8x{0hcQCv6 z*jJ0&tyd+ruRJO(wvQv-4}i#KFl8eEi=f1x&@LO4J$qQJfu}XFdyFAiSbn#wzH2rJ zS2)5!RrC>-qc?pu{zGv`E2h1^&{VhJR^LbTS!4T}@T;XT-vi!b+W)?A-)Hu?HAs3N z_R(^_Y)k3T3b>0a`Y*?Kl*-Q{4*h&szF%*(H@Hrr) zG6TyJV>7_h&iHQz_e>Z?0zuy<>wfZ-L z;v2m^Mm!{+9YXH&mYY+I)RcX)^mpnqWg2-*R(WsbfttCIQSo~gj+OCNBZ+E}uP<(P zsCLNW6Wl-b8kO?NxZ}i&7?}nT#o6YgoxpneD`bf#-9s5zzuWof97g(av1%u2b1q0e zuFA@ytjeb6Nsw#o@%^RYO=3CoYAajj-IoL|w4NKx26SIOb6ptNDV`}kFd-35vRR=! zi3sW~`u@ZDb8zTwYxX@MID_B|Z}+}-myN%MX#bmXuih%-8VVx1pdW4(pbPeJq2oiK z@ak7zHFdeB)9E?b-klVO9k@Wk6&}dRA;1W<(18&11;iIEJO&C4iC~zyPKu=&Zqho- zNUMe5^+%`lX4ZSk1`l8Oi(seg4>@xh3kF%a_?o>l7#wsd_;^lA5T*j?8b+xykzKDqd7T4s3vgf2rv0xeP=7x=vY=F$yT@!Fh-b>c zV(&0t2SG2n7W*B8{Cp)6UgaZ9`E(Cs#czwXAVtR$K7JJJ{-0e7h3u{vq5!3f4THcZ z$_YEdfkG#KV57MC8G~@c8N&F|5`dr~5}asdXPvd*A_t6fy`w3K-^O$Y{Q<~TZKu>BgZT=X`WR6bu4A00YayxWC&R=KruTA#4e`rHa(6&$D_P^${{qhds zWIAtRopwu5m~SoQ43hM6)TZHozQj#e&{gpL`;>wKiC$T-skvw3%^S93wWD*m#@=jw)C(_ zdth|26?=1`ZK~!ytBRw`TguysDy|6-CoI7Phy(NQ*2knjyV|v#pSjhDj>s>KUmt=Fk`exR!#A6a)YexiecVGoa#g_6H@KMK9kSDizi)|4xZK6u%4 z{yF7N*kPL=27e#vZD~_MSS~OpgI4r`LS0cF8QOPnS->y zr1Ujr{|2!0B1^CESYBK??G0HQz8R3V!Sr*;-)q;uf6l>>IlTG?t$D^zC3C*_OA%uWGs%q zWtm|h-`2<%`LW=H=LpwBV>@=Ny_eGN&S z<%i%ESm7IX&>!<~+uXYL5ZnQjJvJIx*D{7i4`*{0ppeiTu;&!b>zE`ko%(0E;PM_* z33)29oC5BhCDf5Q00U#Ynar2A_JKX(^B;ib77i_We^Ayn6l1b}X~igm<1-OddBVQE zyybqiea2W7D5K|be%$>RxA(eUPYxSTe$In0cK2zik$1A(f1~;TEf}6^h8NlzmXtw> zd^b8caQjiypUS~cAZe9k*tWXt_Vt-t#fZD?Kl?PSYG zaVma*fwLUnv;dB47$);-e&+Pbo|ZsYLvRP(7wo(VuO@c{5H7NK&R`$_UkP*-4}-l# zLTAWHo(KU3nqYQY0++zO_|M&+iNj99x6$xZVCI4z3=Qcj{D>+Xe*oTE#-Y>!%vby2> zb&uWK@J8ztlvK7Eh!Zp^uyRHYd9yx5va&bElLY0|6Z`zDtOTFH{MIBV=17AjwH9|3 zwjcldl|$0c{oi0!6{ip6If50I)9x=g>7+A*`^|Q#9S^++hW(GrMV%5>kqiqnsP@4v zBuXF3U!R2Pj5iI5-tJJn5!6!|A zZ<6V|mAn5BS#KQ{RU7q_xUcJ^Yt^P_zLhq1VkB7p^`Q_(`)CmNI%RQoQpJQ4DKvz%aY@a(47%2OUw8{&RB;`|rQ4B5MvN=}$B>T@?) z+Xq2OTkO}6C?HaF00jxT=aI5x%+{$jU8(4(N#J5z%yDU|MTV~W zkp0OE8#_iI*67{nMvRYam5@U%hua8Sy3A^DE}ltCC98$a(|(u}Zj><3g;`)1dug-= zCe}pU5jXZ9KG}$2uoXiVS&AWCFib^8IX&UeWw{}`mFti4cm+x~n6Oj|aZD-Dtr1#3 z0w4){y!_lT8R;XjW)@Z@hI#Q#@9TmT?PS(o>%ALEI@z!Hxx~u7{2}_{(fISYQ0f`P zv0T%x3>MJ?oLR~D+}yCbFY1%1MSf34z3J9*`>>{PPqnG$P?vSz6@GI8dJO{?#SgfALm0GIHC^o$2%2N^ zU6xP<;mOSp$tCwbLysnK_fsrdK;-bWL3iwrR~Ae$P0ZUl7QZJ+K)kuZJ<$9S-vlzo zR$X^XbHPiWP8$DKY%X&)?nL%en3x|cG)_XtzVhi2BXn?kEw<5L@j)<5YxDXTJ2R?L zgFU%ZMPW?A?J;dSKs5RJ{KK-DlXKOhl(7Gx;R!cqrB?HxYff&P%~*V+lSux#oS$exT9hxn^Q z#EJ_l#w}IV(?5wKJoi9}LU%tyB?~V$DKS!uQ;3t$-DJ+)|2n&tcaD@w5mP23tp}a8 zP&E#8+?Vvg1x%H@%>LclFayU^pdlSxEu5V=3|QRKfu(|o&%t{j^sH9Nxi}{UI8FMi zit`}m!x}KLA%2xNK~!594xifJf*l?yX%*I8W-yfI8TBxX!JOs$>l#7Gq5>)I+5o0& z!#QZ%AdPPm-j>R@teW$iHUs{L^%8O2SbX+6SOw-rE?j!6o-eZcy6Vj!2gTWm8sjKl z=JBUyzo74l%>Tk0_;VH?=(K&NaO_C`GdnxYOiGiG@=4U31rc|?bGYMR)LH6@9ZkOXdLQ!zosZ=aZYbX5j~_; zD@v_50 zin1}=qNRzR<2R4IhtMmutMYYxw>YQRHa^meUWa@+8ka5q2tuYnsYFA71&gC z^W5@9W<+SK@NuZhTKn*qo4?)2rD`c9-K(*oZ);*mH>=MnDU3CT}=_2_?g4v9@^$*y! zrv;$g?}gUPxn~yneCEcSsk9{$s_R~StqRFCVVWepO$>cDh5 zK{#8r;7WvevAr-6~m%?6jhsrL%gfTZ59u=Na z&3IFcdAlHuAsp=J@Obp+=K_C?4-Li|7-ou`9}S?$jP^692BmFS2ex0j0CnRCHozph z{!^P*L=rrMaKuy!1@5Y7r7ff`JYkxa0TmZMBi#!C3~xMEQA+r@497q+fVsJJoH}-l z<8qtM!eLvQgFBilrr$yo${2neXUG=oQ*&U!WE}j7X?2&4tE<<$TJcKMo-+U6ttvt4r%;NbH!>c)%82@A($b?!MN|z*{G{3~O@f=_W<&W3m zVwDdg0v0ZSZE{Vd4^|cF$=Dyq?!NAFO0q^^B z%f1U(F;2elNLAhUm9M2|$xKB{l`;}X?fS`_jH6%(s|=-)R$tV&rS9h%am3c=`pCbE zD{q(aK0)h1hjB)i-O^EQUnT0kgt>p<7vp>5-Bffs_=w|c>pkgegEB8>caB`^k+-^? zT@R`cJsC)_+pA70dLK2+N-o(r+r^q)^*VvE3t(1dB}WP-DWrLYDxsIOZ8`eN+SWh5 zyAK$QPk^!U`_FlA(^2y;UH7$!UPb1wa68c$SBPf_Gr|30^_Ei(Q?0+pZ}&x4Sv-EB zt*_-d-;c4xEH1@>f?O&22i}l<#_wksV}$bTuPc7C27wdDf27cqdCry1ZUON%u#{Oh zJ(l5I9S2ll`5F`+>ayc9Z~r{YPN{+QQs#+ks_%sN^mEGf{h^Fn1RAj*(ehgQw9BB9SuqJSyDvHL*+cuM}?V>&v`^H@4r+Yeo3$1gVY z{}T|~&kvhAho0FAK%Uzm;>QU%e%koRWX`r>|LnfoWJR#W3AV}Wz=u5`=V<|+C+02+ zT<+ENn(dR@X8AmT39@;~bPJ02;i&u7x6|Q+7&kk^&Y2&tP0M!OTJP?I1{Heyr$ffP zrh!30@6l&LWHFsU%g5qK5Hl+iuzQgx15_&#sVVc0$2+k4r^Mv%P#XLK`m>*kPHUA% z3e>7sw*8BLN2KSD<#x8|$HHmFy%&uYhS#OMZ7u1Z=dFkTZZQzl`m-u}OXC~I7BlNm zW>JNrpW+Orlncs`*KIItRRgN0dXHL~@o5%0JH68|sAfXjY8Qr$*jf?T;fp)y`;#eT zo$Jn8Fq%8yPtoq`DKK0bNLYq~H5rboBpQ;h-F3Rl7~PD5Z5kGUqNoWRuM@qoPK;x` za(wQ12H6)N{DZ%q;}1C&>lkCs|L<{xzxf}bO8?(Nl^UcV^7Nrm6Sn@*0$Eh7Z-3TV z-u91L`#-$H`d5}-xlulnToYx758=&P{Nk)T)a?Dre`n4}VSZ6lmMlVW{7TiexpD8hN3e z9vwdnf)afOuXQc1fDJ;Ip@;)0lHZE8m#6>37Fg$ylxQEuI~_;|JbK?w*xKS^W?wna zANDY<6<$f_KWh11$K5_-wyLMescXP1rX+h@H!C9j9)S%ohCq6AiJr>y zw%#X2mXVOo;8jv3-GhbnImZ*BlDPDbnGqF@Jsn!L=JlJclcVttl__ejJksi(e1cp) zJ*U|bg=&vnZ1-_|G*X%iOz9=d>0(R{94{T;JHIbw$2F$9TFI#=>rd?|?<0u_7o?1O zKAU3liM}4;p8tw3KW%RgkUw8?YitbW(JD~r_hY6HrK#>3yXVbXFy6fFn>28^8LIK- z{niiy=rP|;)mH1iNGLB$$0Ns4%;f#~SLUz~;@1{5xQQcmm||@jCrFY^@u=|`&3MW> z(+?1A%*oN2ex5g(T^Ne|p3{i)b@~pneb4j+_QZgS{HYOpG-__mC4J!j(xHiNX#72P zov^ZApxN54aAo>$8UtF!m5>}Z8Rua1=Dtt1tx3RYNr$S<%kWo>M=;48xzyOOB7l1l zdO=6~=`#i&!ER4-kQp2GlSo&Vw}L2)#PDBHsBI4W=UBrkZ!K#hsO`(cRXI#zUHAHO z#_4Jx`Upac+Xs%3<8Uvc=o*9!m_(Us`MqKA5Vshuwk1TK4lv%J#XYuyX^7<3r#C`_LmE70I)Dtq#`K~e<$S(EM;)PHI*-}Em7?!2$R1z!^9 z{T2IbkQ;T_UWd#9RG)22+$a0@>%5lw6}*<<{?JST*jd6>{o3OuGv;r5HQrM#QT?GlLfd@LEsH!GTwa zz+p9ZzSA$~r0x#t7l{c>kck|Sl-hNb>VK1OY;?z7Qg( zPJwUj`FNR?Mg2=?@TRc4MCG0?q)~nq;+pSS;!^^^?{Zb<{`>SN#R>-v(fem!0#mQ? z5R2G-P@wdfJ_-VR${{g2!x5_@Pbc&no*xgMdZD6@`X_k*@OkrX{_+oC?oWOH1h^ZJ z-kw?z3!)yQUZYBChEH6R{F7|=3=xS6cYeIE3I2YZ@lM!I`zKHhH=lV;=bwN`9+fI9bgeEM8i#6#;*h50Tz>?45c9AUVMZd8~4l@d; zy*{jAJ{$TqxTA|}=Dkv8%j-P9zTb64_!nln>?8f52lPikp2u$w3EewUvD(7mQ(|$& z_CcAE^xm2w-iv2!bI(age?;@%yqSa~89G;{>i8rz?fj;8;XAkbqQSK6nl#c+spQBg z-f~;83YH4f(mHRev*xFi__v{pvkiRg=-S2z#v2Feg9W;Ijn+CQr5TN^bw4tODo^tB zleK$)3pyuawUf4a^1S8&-J{CxMUHcm^)-|zG()*^s`)2}V1$^v+Oo^4ZpA$!9y;pz zCRc;>-SOhl5mm4rEqA8$uu@tq-qb#<0)3^?5NG$8!5g3TIf$=>Ae^&htQXifEU`VD zul_zn0LH1QT7NO7aZ8MD712$6wOa9Elltr!gLS+%TKu`X6C9w{>n-y$ReZ$7s{{85 zj~Vapyre5EW4c4<)C8&r7cmlQSY)t>3Ej6k0U@i^Ijn*PMvgk1@B?_LC$BUUn1CW; z9LniJP)=>s<&rdJgn8`GgpZ1yO+&HSBXvX1)Nenap7tV>3=h?e398X2+Os9V0witG z&_wNuh`}eE2Ra%~)D@%I{u=oBI!2(0jU`h9tj{8=Uvx`woH((YCyD7DKvnc7Cpx}o zfe!#{?YD2y_w#4~%EJ4BWbhm4tw5(+nyu{?4X(LpaPFs7C{c7e zS;W@Xz}H;9b3CXcWPE=2iN?}~nv&yrwZcgv4S#pLHesPPmQpCQMx3gy`?yUd3B3Fm zh(sh%kg`5fP_Zg%v}@dz5t!k;|Xz|1H%ipUiq^!%IyVVZX|Dm z#s^OU>eS$BbYOxDEiCk=`VOjAEBt%OP1qhtyrAp@(r0g@GAL>>S{}jYrob)B4_cL_ zC7`HNcw=wDn!=P=3cLsuog&;0D>}BHGj?_s4S|k71?$V+F!%{(Q0~ z_59}vbQeL1x218B950%e;I{=F=6n3p@Un(Zvdq(q4^K$-qr$aC1@!;!B+V1DzZ zE!5`HFK+B#zd?i04%0Te{dRl|MBf=+LWAase-xdNb}iq>drQ_FnA7V&wy;7QXj@s_ z`)h{o=lbv5BtqOTFYkr8{7R!8`Vw|lE%a48K;5`=r0&VCSt}b@9~_($kF>0m3u7PE zZm}+tYly4VWFUL^id(MmRdz&jYTewCy8d`#v8ab$;~~KTVDqypf>h9xXvJ3d!m}qN zR+~8AVpb`dCLP05Vt1&$pKe9QaCh?kNH}-_TEtjyl9%3VET9^c-ZygU zC_!rBVGkuoTGbtB3c1AodtSQUI$XR*A>d@yYEk$!0IoS?Vcp1*CKo~`v=zzCt;>nA z&3`$wGkx{uBYXL^78Ft-=yk@6VfUU#z|_?!1(q3qx3ShxR{m&s`mS|N_V8M+{Em(T}ThrD{75Xng@T6{GTJdO2A-2LNE&o z7jg)^N4uBFqhrpYj;LgnX2f03yGN;g)G<4{yq2gIaB#!7*!_XLr)rA<&Jtgo(b2t#Qz0zzevGJwI?u0PA#N9^TUx z!zlXd&`K3vnw|mW5Mi+cr5tFN`EwXC-vVj`sNI3 z{nyw~*<;i>(60%q;}%sK11tM0aWAaY)(q%_&aarTdJK@Ads|CnW~Q<2{PXdjPZN15 z3e2IU_uCjU;OHjEosV4`pl+dNKLE@BtxtIC?HhoPPmqdy6eahh3D5*qHyn(QpfNBP z@-`va*@6NT*A{q$4Lj`)Z6BMxdy7`JIp#n7THRR+n~;T@zbz!1A3hddr~+?7qerv* zL=r852^PSf_XqB&!LFfG_xoZ|eVs&GcDrQ7Eo?JA*1OpR{Z)m7q^)6}qx9be^@S~W zz|S&JzkN*_2MhvUje{0?v|L8JW?@q;1Gx#ZGbDw zx#joM4^`Hl?GC-~)EsW7Nz7F_#Bshb$UZ_0Lu>DOGCBzcG4M`apdZ{$NZulGy@?I1kEb1Rb`IcOd#B(pyVC~fgNTQNy>dDAl z+rMFjCRp(J;-R3pWd-$;ETcvvT#0iz-5@-gXM~2=QeZ=!@mGTpfzf{6<0s8!O1w1r z?whn_&q{y(!{8cLp8b;7v}V18-_%)wnjTT9xbhuqmsX|R+}a=&kFV~qxmkJg!o25|5w3qU zW6TqlJS1W>2TfQ773sL72rO+3Mgnht`xVJ<6(mFrt*=(uUUVb&10ZfyGHDA#{1J6x zDSx*@9)1?^j>G->p12T4EYt>&N55sG4>rPTo<_48(99!D5p}?n&GYq;SUm{Mt}j~E z|L#)#42*T*yxyo=O$@Ty!hrHT#UB?YuaT6L0YreR7=xsYC(YBd1p`LvKeEp(syNler(j~z0OoXf}=>E7p0$6^h7 zn+HIN$6kR#PXsTfr*@!W=1x=UCm|y{hBNDbZh#TG^AE7Sf^iK3Dpkhs|DaW`KX_nH zS1&?hpib^gb-N-iWQ5g~w?gC4j>6v4hL+E%`~DNBa9EE6eO1P-&RW0rWxKO_j5!kq zVo?0q2_}E$_3+>wrUo`q4qqgzEGgu3&^rYl!H-}GM@m#ljeXFS_eG3M^Q$Ay zrn)H2j}af@(O|lx_+8Dz!6mmVrkP0$2t8PHnaP?|bf#6P1r8cizpqh;*|IkkmyS>d z<|W{3kN2COzc9-&lX4lRof;ozJs&08kk}Jo_pv23>Z2VrH{0D8x^&k8uHnRt>NH=J&w&Hj7 z*r>G2^f^!1*XX&8-&cL{-CKL2^7U-#5_t(Ev=8HWOkuvk4g(bHRi=;j>SG7`eJ)Yv zzz2+m__6(i`||th{-vK$!b3}La_t;nc|k+{ZmmNNR7Q*#<^_9q!sHyZK5e#Zz0`x} z_x%MP5tM@%94w=PRf?pv4yS%pVtz>j?6I-+k!9!%mRInGi8NK+Kc?-IZq<`L&7sEM z=|X}--+X}Goo&CBqOzc6-sd_?PQR1)Pwf`?C)XIKt#l*Rp$IsF?B?_nwIWs`U00>h z5Dm*f7T$WT8Tt4^_Y$IB(ivrYhcN#_m+d@#(XqGRy^@qh0{F_VYQ<;{rn`jL-DDou z*Qy%CR%k{`7NTQcy`Hif7OEH2Dco*3hRSp+nJ1s0*n5%AgD~9)O2&>M{DsV9sdHar zLIRnp4<47=W+1(6TJEcR3hzPd+l#>jm|P)tx{RX_hOSxCZ*bt9AW-vvI!d}drB#D zhFFRY3bSX}31oGd=|6|d|x z8r#`NLDWgYSn=`(oCD?A;^27mQMq!OB(+phi=cwCKO$7FvnwMW{|}MD^LaWvwfd`x zOQ08;et`qijIaNA2Th+MGH3$KX5}kZR4jcn@PpQ$(UX`iJ&N95<)l@WR|nRH$KF-< z5@Z-_2<1PZIO4v`4>V6x8`gxylWP(Ocj(VG!8+vryofY&IG*+idrnLX%m{d2iBRLv z7_MW3aq|CChM7B+*c7sEtz6#Ru+69u@T2HjASmUy3I zD7L^qpzG4v{IT_OpMgIt!Yp>Evlu`Iz?#X;cqhvfrKFddmtoYyE*||r>p}n@#<9AK zc}&lh*~B_oh_{9V6IcO!s}!2#OM!ht+|eKlZtjhy94elwx-O~s?V_Pr6@MZH$i^xO zpSXHzHhvPYs&uO*?(YvB@O)Wayh;BAS(jzgBRH_M*jcKY*Br5x= zXJ2heXH#EFbRT%G*}ekJ+Vg{fq}o z?XX*|P$}=U85b&OanK-}D4vB7F3x~R6&I^89A4GE_UIr3Z#9w?ZPxv8o_|?^f6?I> zsYI%B5bBRdXD{Z0Cp>46sTY~~#UcUHytI7oLA2i0~!F z44y_jvV!C-x+LfUjwn%&eFx8?UM>|wR%rQAHu7YTHt_FPLmyo<_ zXW;yo>I{6QcOLP|zuK#a(FX;n@>$&1$O`GSljq+Xn1y!S`+;dc3ALl6OUT%yTRj*9 z8Di!4Jk>u8JIG_U^x0IY_KO@_iv1dJ^Ze>4I8NyGHOHja#=F)3#f#(98f??Dt20C@ zML8JTIS@jRbsl8xk~`4gj>3GRx7o3Y!7NW{5IzJp%V7L0ww4iv$OAyW0R zdY(aE{`=0T4BPMx^xz)Eo=6^tZ+M425d-@I1$GmGJmT8g--pP(t1zzfeE_;9Eo{ft4MS3*FsKo$(N~E(ZgI!3L zb@;KeswIWZ6Q01{_HEA(2$qR{Ws&BNa7z%hp$#ngq-T`Y9q=0U^8>jN!{|!PVGWUt zsJAHg(@AmimH0a{BrLlOl;CoeTe4^2mE+M;$d491d;Q$=3-4N{RjlvCLHb7Yr7O}u zEOfSzlBM{b)!?%{Q_=sBWk;LCE>j(D@E&!jGIu^xL^HI5vvjqlXLB0ee}CB>|m_x7X^%&)rB zVOgbTAoAzyDwKpn`sp$7VW*+|YnhD%gBEcG#IrHu+M{6HH|SYq;UeF4@1fnt9BcL^ zogXLAB1p%|r>R6K9Z{FJW%4s3ch-b(}HkQ)x_ z=(_*ON`=xX{N8JZx3)4(B7*=neSUHTnSu|p9iTkryg2~@c_5;Oeoxh>!lSi{VMXEH;(RdVGPfy#pjpc3}UuvEo>WC(GC zt`U*IdGQLyF3r>msG|?x{A1LAuou6}Rc^5b9U{(C<^7q$>TDx~DQ#79Astat`Qft> zFD3K_d2DdA+v? zY@zTdnX-c4bYb0eIH+J;ih;_~Rb1z52Sp|<%?1myT9kh_?8DBr2%!dBNZK+o zR=x0iBm0oQ$fz*Vw7>aF9412)5Xsh)(s?D)Jx^gn!z$;68VraOKJ$DpaYRrrxru-x z!LZl3A3pM7IA`HwxCsx5Gln{YG1?1&$vAw!Pvzx~>}co{S*_$yE++IZE-eC7}@2Z(fg z@kR1a%!e}|ipGbUN=vx-o8hd|miALW)Fy1mR8Q+0$hu4=45Rf|5$)Yf`+)Il0OOc^ z2nJYtAF91n5&tPf%T>1WA-krsun1%KtF)}zuUdTN&-rHg2Xtd1tWQTUdw6t09yrXu z+dl}Y2`)uzi@Nk%KHHc61Nf$f+AM8*bJ}vsLlm>f%gHXx`w;Rahs>%i zA)Tr{^OL+X)mbp3G^0+03HmW%cQn+h#0-~FUrw3;Pk9bBjQfl2i>21U_zCAbx*mPP ze$Y3_n#*i@Z_6@;Q8bBysKFM`oNZXPB&J9&Sjte~S17_!>c<1E&&q-Zmfs8kX^h@c zL`~@}1seQBOnrm?>lA4o`vr%Uc49oN1o70aJd6Fpq#{L84eVh4T_O|vl=inopd5_C z8ih|@S?G7qp82_Rt^v$j9l1nyDuxVph_&A%~-0^z%b>>uzK+wrC8cR^nQ^`*4h(D^xgdC29d)52>}eZ zHN+>lrYXvBPOhKb!9GxgxMN4VL;=k9M;gF*fp#3){5!sqFZ-7)K+-)4)x8E|i)6Zc zOm?<460&hX&2`ADBqRzLknV)T1vwaiGER0@kx!`Nv28^3<-eIT_j55 z!trtowdD-H&5~G~Q})IASBN^60i2TpG7#c)d|`1AI&8T`_1lH$V2;>K}t#SWRtJHP3MvjiiGK<+FNj%~Z*n9KKiZyPAys*N`dLNE6)w1)Nh z*pd?HC!se;((vt|dI*;Nxc}JSf*wF!=~qaoR(2&Cy`q1}lA8TC9q@Z_1guK~CF;E7 z=Wzh>g_K-6UQ}0(H0&k=I>R(1H@EEV`LnEAYdj9X){iv4IQGDG0`cB`%~SRsv;2{u z@G4G|vWTmEtV530qK3;TC9C1<##LtS4Dhcu`Brwjnzd?zPrEXZem2~oQ0+scwMGMn z@Vew&K@1?}#&V_@P4EIAON#Ep4z|<=BuJ(z$|NU{n!RoJvGZks9>pc}u3-Yy0cdVr zvf#KMxz6aeUnE{-R5T7*M?eXg-lWOfU)xSZ83M_g@lOESVb-~@BgOUOnyJlRI1B>i%5K6h5R?%Ze zEz3Ht(7^$kPG6_Bh9X~f(dh8?vSN3k3ErfdMMj`9pch+wZ$joO6Io(%pM7e{djv29 z6!{N;njZoTf@P0J-ykPZ)l*ME&`X{i>3jO>mCG0Oi%~0p{`_u?uDGMks50+pZvAL# zzES$2q=Gt1GyaH41U~1;OY~|@{|obD((lUQ4EFetbJXB{4P^Rl&JQ9#gkEsN15$i* zf-1>?WbKccQFF`Cxa2GF9i9scV8K8J3*IPctVFy|=#tlhJhHOBzm?58hUyWXR;xErqu1 z=?Gp-uULx&W}otJ)+}sd$9{@MJ?o~G&AS#Dv;+P{Ve?sTuf%(Vc|wa7LyI($eq#0r zO{N}4Wj>7$<^h(($D5G<)eecaeZIa~C`h%tg!lr_Yw(`Z0k1-nj+CzdW+CHP9*^rj zre$-b1)R|z4QHc}JUNL8j+FpK{BjZ%E)@&zcD6?* zyNm#pi6w^?ZezgDR*U$gi!9)zrKPKxW<-O!K1R{tejZWeY^l z)wQ8i?FbN|DRTsMhhpKmpC8NAmPQw+c}b9#Kc+6m(W&Nl>ch(t;NdW=hCp*PKjNcP z{>VzHheu6nn^9}F<7;L8mDz$ie9d426akcYOuv`~5)}UFtkUWuwR8mt2VH0Va?{Tc zWvm+c6#usb2Gr~)bd*?)>y2~?#_6VBFW;&e7oVZCQV|YaS4a)MtEX<%3Ij|w`k>Mp z+3Nb+Qtx9!(+=pz05D<28Z2+o zmN`2M^eSXg5C6pg4kgSnP#@IWNiPO$r38VDlFkPG0tS;VG%n&`5Ao_ka0_>9Brxh8 zf$mF+NkeZ>q3==StiVR+JK+%3AF|0yAfN#WIG^`~t}^?rBNGF{^fE!i87DlL-w{~| zsMir>m9&hsO`Q+{OZbUHQb}w^)h*%Wr%Lqg{8<-P45)T8n8!+zLYR#oP1DkLK=-O8 z7EHpv?zTp{Oo1hh*!cw;lc{=wkT9---_duE%gCsUsXr6iFGQ-+r{OhP)<4;pb^P0f z%gXTNnVBU;IKOL=yQ+vRtzt&-$D*It5Cs*&h8OdQ8O%%%GQAE%$TKps-=5Jj^O6d7 z%e(~T?$oKxgIK_c2wt}r4LN#1WDv}rd)x*1ys!WF@VoQ^3HBV%YwT*aX*>#JTL*fSSY#y zqCbE!8;LxaN?n(iqze*3Qm6bFQ@aZWcw;+akL zp_gG@Ng@^{mO4u;Sd02`8xk9g)%?=xh8tLUGqDOPWvfBxZ`&YnNlI}IS$BS z%%1_QBb_f{do6%-L6DPU&FSO(xcUC|h+OT5GM0$R^96-^&YSOVW`9w0;FJ|o;~fx$ z{`XR8a)pH8*l?%BhWWKwoB^NRQ(CpGLAiI#*aXGsMF<=azr|w7F^~Pj_41I{w73Dz zu5hQNJ%Rz@lX#~gkCa~tPAl=*`+d+l$+(W3|0o?p5^Sfx3lE+io4tZlAZ(@7rx#08eAMt)wd$E+cL0@{!7#)CdL zD?J$=ESP2|CcW-`k=^>u8c*U?H^2ZKzmRCz#)2%;QT8moMZ_3%&^T~=qIBCQt6~@m z@r|2@L)0^{&{}dYl3wPJaeD$<=M6!AW(24V+{Nn+ z!cz(^^54_A=qoTx1aG{e7)5@#y^T6)=edEZy0KY!_pMu)B&$=T)L^4M=YSt#m{Ppp z@3%KtS3sD%-U|(01&#{Y**ekjyD?BN%u!t`Zpu5ge{`XjDOZ!Ay* z2zvbS71b4TnDH8T_~g#5;_42IQ4@Ee>RHS3J~05cZ%fhBaoLjDEu3zEIM4^48Q{AKF(Od zNk0A(7`B(1GLk*45=JYTUlw}!%KU6nF%q=37dF=NE%JA+k1n(IoIKQ#2@Obd7Vt|J zJMB^JwvwoPi2j(~?IBUw(Z?{Y@(>D4|FqO2tCHH~Hdve_n)j#b0XM+@6?bCyM|$*I zcrJ4=Oy2m3GeM?R`ICX}warxRLf+haGZy!M35Fx}2Mgd+3!h%ImP00ezpiS~aXqU8 zsQ7#;0=uQJ9xJ%MyR`g`v^P!g=3hIe3@A74C+RGA-iXI!xI+7$U%h3t&XJYU^sZWA zNP4P?@`*H`0n8MuVbWsafcwY)N}KO|NKGFs9RSyi+z!!hXU80-F<9rP?_NI}E$|aC znwX#8<*tE3hR(be5#JW}J_G;kSLSYOMRO3)B{*m+S33KIMde0$lkx}yacUM zYy{{!69I;=eJ9`{<{>nRjQ^`OK6~rz%;uZ+Cf}GKb^|FK_LrwxPQcdQj7zqXAGvlO zRuh}|2=lEn$NytJ23v+59DpJq9g|hT_@I==I?lkVe<3mz=L&8kvW}>UG3gs{U(51` z&xYkWbb(u%q-UZS=QGOK4BJN-t2@y|6WFTDsWh8R#BmD6*%}QC;Q0qXlbT)1oP3e(`Y*8?3W4sX#9K$vXg%*Wc zS-YYOlXBo6ydE@^p+_6#p77hNI9~v|S72}!KCh5Ania1wA&=}&vzNw?4bq?(96>64EWs8 zm_2Cpo)A9?M6*}-o{bhQAX}_hD={?+n2Q5gTkyf9&&Ty=;`f0M;CU9RYf5N@bT$E> zs^T5sKo$`L2e1%P51%0KvbJF3A5jWAdT*@=9;9$#4S0nA@)IFJVz;Z2U10A$E1z>W z8V*{S!@6(3$9QULfz>Y}p&QETi331Ci*qJ$UhAI- z{yrsaSETr^@+LTW-&6%>VbV_CZd={g&_a!E3knw`UQN>-fLyb6Oe%8H0?`l8f((2& z%Hv0kaIwlwkN{6&L5To|KssCK5yNNaWciG&I);U(_SF7yXiE=1HnfyTqbifuBTjko zm-n<>AFVh8XG5h8Yd@!4(^81iE<+#nK~WL+DlYNC8y*rlJo3A>^5gf0BE1WO1w*s5 z(&au>L=-18EVvO1GNT;|>wv9UNXO9j55EJ1Zb7FRDk}H|Ub^g#iveGFT>H>CiWVCY z@swrmmrTI0vB8;(>f3a!aLQ}oc;O5R)bL;qwGx4rj!p7W>}WtX;_Ta~jdg8$oB{?) ziUHns42P7E%q5?$0loJxj(=Al@Xh>aRcf5nfxPA1q@_2K$|HHgLt*k+ z*7cW!Z0<7OMtjJfg{->1KmNXMy5G_tS$*E_t7<1fn?1%vV9vBCylgd4>6*1X`lrQ> z8IDu#lV<_IFuVX_O#Wvw%FJW?bM-Q0G(jXK>GDTCBAmiRlI4?{0ciQvKeNjh%HAv` z%hJ#yl!my1<;cZ@bYw0m(~&`Nk!Ai%Ate0w ziq}$dw-We*NOZr$Cj}T#QDDrY#}40YAF(@pHOz%p37o@WrU*#f4T-fq>S&3KI)Q)~ zn3GCL_2SOSZ!flYCr-Dl^&UY4e-?XL&+|vP1OhFHCvOcyms?#-LhEj83dV!`Flz(- z*ye0^QjjE5?u%MEr|p@*YoGyO0N;m|ch>dHWZ+Xk@oY@iKNG`aP>FAF7RxH|Tc4pM zBlnZWs&$VF5FX8QoNRD4+cp!*icbs>vE}9p>e%{e)2ar%GAk^x9I3S)B4NLY`wpD|kt%t`5 zPE3^rEw^Wg{fqMog*T7c1y}xk$?i|_l1BnF6T{47?xbX&tS-jEUgnzSey`o7qZU<& zGbIpL&qXTH8%=Ady>pF*1Z}JFSWO|RJTi3m8VV~?<(f}zKl2$rG5SU_O{M)3gMwjh z7@>8&2;e9ayWJ)&ij>x+v)W5tX5;uj@?N^;*vgA@5fHDuSdC;4za&F$;rB{JFjW*= zVLSiE?zyDDbLYj(=34>v84F(FDHj1qEG7YFn9KWF4V$*`A8M{|2WX;RI&8yxvf26E zJoHj@$wrQIT}L{w#3^gLJs)0x*^{~8Fij}y7mxdYh&%6~D4Mok6C|mCWDpP~DoB(d z3NA^4BoQPh$&zyv7myqUL~;_4AW?E$KyuDGNshuwT3~nQ%=$d<^S-A}s8jV-ov-Gf z4L#jGJ<~ni_kI2D{>F~~LH207^f)9Snf}5r*(BnNSyi0G#|#B%y}#-wC3p* zj#VCg%d1KyXF~^IT4*H>F0$r5cM^BWfzDsV&V$gSG*N)dMG=|FmFXF9>uNM+|BZU( zi#y|nWgcithoMJkQTyt1FyIL|jl?koJz|$ZVD7%`qK^Q#Eo68p@P1PyWgd@-=xpzl z$$)+R$tWo_G*fl^ZP)T=HJPDlVKnWu(1z#jZtx!F#T_?X8BJrIdbr2RO34Y)X~igi ze7CGQyU7{mGvd3EC+W&$Z}G2K0LGQVgP=htBh;#utVWP;t^lt#q=?s8EeAH*NF{O| zk8OEdf`Vy;DYIX~Zil;ckchsag0!bkY_lXSfTsNI%n1GT#|_VyGP#;6Z8v5FZMUNu zt=@;$YHA+g)aVMIbTOiyQa|QPmM_I5*YT8gSYSNR<9<+uNgzy2@4aR*iTC6_GdWlO z3ZCt4@C0sM3bFglIRAWC&im_sxf(n~g^R+?JmUA8h;QL2M{bl;Kt)P$&D=;y8-bbm zo#TIMVAJCaX7TEuEDQu89eP|`p4fWaV1dzS#v2StN~~I#3O{Vh7Wox@R`Qur7n2}0 zn7G-gauS4}$qTWS*T zi42UEfBx_pxY4&oDgw54`y|1YEQxarTj!#?2~+VDat`p;&>s}GN|KT3h~n`YkC$hQ z*uSPfk|g_C_ODwh;;Oll6&hOnukW=*#E7iWqdzT$xwZ69xEx=~$o$jLdXxC?UdkZ; zX=vhfs>k=4nYlRNAb&NZ!X(_@PSa}_&wic65BGZ?!=F236`lr`Tzan`o)s$p&qL%f zioE4eQVc!=)nGYKFFhVQ8VkhgV=7vC6ueaTbgowSmDQgFn1^Jr=!WY{8P3GU z2Cx0|J@v)E{>O{VRCQEndWc9nH&Tp0PLmE517#cK^w5xUUNc4_698%TAT7520rtqfL$EubO zN*%$^UY`N?ccxjHe7;TnlUHS1#}RvinaW;@J}@p34nw$}QLUD_qr%}#m$f#nAaz2A zK1%5a?LbD{d~3rcOC7*`3~=<`*Zw3I&SWWsimFKl9szdh0`Nlyc-bM=kSO34t6+ys zVH@W#k$H3(QFLT|x=Ze6s0||Ux9?ntq9ELSsLWH~-5zH2kTNtRNV$L<1MiNZQxM&i zrenwyR+4c%4-5e3Z8mx`z@>17NbjLir9X4JY26O~2R&ZBj-ISnB}%ulp~Yx@{qhlc z@sWFBgZoJ@6YfbFw1T@Mix8|IUoQ@c-1v;$%gux`g`48@g*XYpnsk2bAE%c8TTh|s8>=Lxn>Hw@wO32BhM%zOUbeFxhvQz37#4;Kb8e|JX0dxabk%uz}pavn5z3hrlguVxi6v(`iuMds6G{Cl*(!ZSxk!I+l z_jnsWZN|(ae=$M+n(Zys3kC`tfBx&S8=|Ad5nl}aMChbQ+?XZzmt;1WH6$qcPcroS znH@P;)HA45mG4IiUJjCkbeo*uNG*(10RAC`{#^h`u}k|!H~rvzQvEA(Xc0m$-(yN; z_k{xT!D+3~O5mERjmifB&xMy+QQyzN6$MdDX(CkB7t6o_kO3H{C`18srOnaZ%6aH*PnkmpC|~ zAuDHXcL10Hur+^^f96K(wmm((HJtKo881j_dJlNDf_p|?LY>y79lM}iz~^aTkS$$+ zf_9MuO_TE}f&}j&&W#x!Q9(?x9B3tE{RX1)@Kk{jfEogzbDF0AnJ1$a^3V&#YkB!h z@Qmqd_)=?AcGi`;obaLXyt6RtwU{YCn*-o*U2lmzS=v|774M8q-h4?hyVCt9fvU_( zFRd!`&=qwzhZtoIQsM)joz)5Z2N}M4mr}f!uqov*Ff>Hz-MP@PL)Sruvxe&SL4ScD z{>yIk8uZD%$LW4m52##T6!axsoNK@>4fJ{FpmuzU4=InvE)SPl(h-l~a_Nq%r0iLP z-C;13>q0pDk`m5%4mKz+;8!|v0|PH3RJsCpdIX@3D9mMWV6q^&ii!c!0B}=O1OV=% z$+J^HD*wK4j~Anwd!~xaMC7+H?V*YR>+o^{>|Uy-64c>7bZL)F8Yb9aj`KR07}`&)}=Wmag2 z-w5a8^BzsXk616BU)^OrxQ3g6yGK-8ccAIve9l&~(04=3kCUUrv)PO6$RZM50U$Ed zMta_@>=&1-#`kC%u3#q>WILx_i3M6rZjzzbJe05qNuj}9-IR2wOz2lG_yno3E zQ~39;p)?k%BIhiEJAMlEoM6kelyl=d=NJm0n|y$vs*N-_(-srLw?@cd3|;@DS2Gf= z1GPk@pVpR=Pz}ky8Tq>|=BQ4u*1R&9)i}sKW+GsZL!V9+Ln_e&mo6EnTcFL>=I8uI zzdHrM4)(XFs>u0Y`NLa4T`#@D`9=UgX)tyagFIHm33cAO?>Y2T)`i~p(=hZcGbudENNG)0>dJ0j_*|3M zuyY=;hHQnxzVf@7--tU~xP+IJRo`32N7zpC_<)0NW*F?5f>`vx<#EvzQ_JAz*l04f zhI=yfL;1_l)Rqa*BLgx~8BgI%AC#rntu(BDWSlxo!E}Ik;Y~}YWd>&9jPMTN_7#>Y z^4KjdI2kmgfhM=%;4oleaL-V8DmL*QY8ih}cVJIq9&1>_@}dI>12*T=ey@^I09H3M zSxvI*(L6Pt2Il}6WxiA9=2xjFX^Aj&<$~3a?8Zgdxc66;P|-pk^|q6in6kk>+mKfd zIc4&(H%9z3-nJEiXwOnH!!0fu>{BUvt2yI0Ifkmw<8pPMSYgd&q`mT?`j{Ui3(PD_ zPa!e~^OK<#1RazYT$?X1?+}9_KF4|a-a0`%kBY%4dOdjC62n!lQLx=1t9|?MKKFWs zhtAmUosyrWK%oP#0`A?BR~1=)6i{~b_GhQnvcWh3qduiDx+*zb7hd!}e))^Ei}QWB z-23YsT|EA`h2k56!u9<~PLv`_;aVZydWA2)d^fNskI?rsaQdkB?e5-1_nAma1OXU& zwhK*d&u-FLGR!T_;PZn^%s7 zLp@tY`PC6fSrr)9syKWod=b?6T?$EwnvYQW+C;JiW_thoD(hq4A4}Y(4O*Jq^p04D z7M*f1TG_N82jBUJt<6MODlwH=wKw1yd8FxZp)2=Oa|%2!2ht^~yp6xB^WDSl^S#+dn3*=(S`23rqS3gUOZ$Vze zP=V20r^P8AG^H}1bezc3THYLfcG^&MtF~>$_DrS%)w;A!B(?orVtn&Fqx(9T%ltL9 zfg@ho=cT`Q*Wh;_*luJSnrYYa9cCKMC8{(wz=n~DrQ&GYp+B>y8*lz@J?n>iB*69T zvXd|79Pm~M$;pCGeQAlK6k&d@(V5?6)ciget~ZtkGFnDAd9Bh_z#_gN!sAy?h<$2r zhJOCj^8cqsvM8T7H_e#rv6r=Y{hp?@W3fR$%d&XsHyEz7q!?@w2MNs7af+###&H$S zYoJx$a1OSM$O{4*7>c@S~qm>wqqgc zd=w3_7u1s;drUMteQ=tSD|UnEC)O+dY?dcU>-@D}7$4mhJ^NBCzmNlQ5SWmh_0Jo7 zM<0?i?qV_2i6cmYOG}=6I6&yyMX| z+AA6$i?=>A5>QwusQF0b_U)LLCUMQG2ra=hy1+c(6gEu;jNZ`0eaADwUv@+s1B+Te zfl?e>AUj!q(X0U?^dOIBNBlT?vz7r=d4hhIP2l@hGC~CIunOzMiy{k+$Eot=GyU4) zaLe-e;|tLM-Yeu4>Wa51+v+Oid*&4HT71I`me0>NFBN$`^i#VwEza{N!43(MC8lnJ z-^%OeOEQ3Yr4%^i3W2fvkZikUJ=x+CJBF@iB7Sfm0z-FzufTUp-b2#)7C*UPgUR&G zrk|dp1+Sp>qmd2=_sCg@dQ$8CK9nknYgh+WO7hGn1$Z`ZLxjDHY+Tx7oqNwO-HS>% zg+)>n`3)@n_DJGy3d$I3d{6wfcF;>;r^k0c2R7rg4?%OpTWlK1MB~ehSWWnlA$f4a z-v$_P{T_hR;J&5FEzMu%5wIhs`4k2-Z&603Be-1LR?7&A*&?zkMwn!3@jf{FBPcj% zIU)gV=n|+zrps5HgC6FZocJWw`+-3Nf6SZUUo+n~nrfV11bT!R_c-tk<4;bnU4er< z?S9gM@JWKeF+h0?bA9D|SIndfmSnLC?YhoGS+A0mEg$ppOMXOdxT~RwH}*8t6ZPN_ zPaE6|ck#dyooRwjR8c{m(*|j~eZ7Jn)bM;cOE?GMvX!D7iMNbz&Jz_*Pe~iS4XBI@ z(=&`wlfimH$6d{?kw?Yzyu7X>VC-7di#x~qW~oO3byXHr!WGq}9X3L;Y%v$xs)`ym zZZqbB-;QROsO4|m{^VJ0vi0u}I?9|jeD~qHivRJG9OU6gYQa#DIMvpWCaZ0_GZ^ij zOIZOsPVOx{>*- zKHJpBUxAV8(ep1p)&IHPywbeMLZNKV=5O+$d(YW*!)i=aF24@RI%0~K0*jx15eZ)Z zXy)gFsoioA8T(oB=Nj(AtvfLxgo<243}h>>r)o?Yzg(^U{2xEXyw|?VZFLKN)>_zO zAb|d2FhM{Y<{5>|O_oUzcp-}ld^MGA$3_8&$nLgCG8HaWJ|Mq_2~fmdK9%69ao10+ z*HpzjVWFL;L?=kuxr7U@8xQ{U>~frZQkT&k3|l027J@exfX`-FGUN3i{$;{1O!eNx z_uan93>tMv`%hf_?CIwUq77@kI`wtIIu7V+t0N_ry~kNAcD z*#fvmv5)7i0Aw2rNcrMc$L`w2i|@Cm-dMR#FGKdo`mMz`g8Re-;5f8%C#COMS5OW`1?Af?HPW+Ib=R$NyJN#!$eDc3F5 zGj3^t67o=p7(nODt+E|LTpvO65I%z_$TZWHZ_P7Z3IO92C0%{iyYmR+L*C2K*8iZl ze?o$YFy=)d`=|W+4`Cc=2h*@uv@d&>2FHJZp_yi(ul1TvE^4Ev_912`7C^<*z4)X% z=t2x=V3fFd`b}2Q>b4Jo_mit(q^e#~b~hR`hdt~_d(kKQV<+yD&=AOV&g(^^f_Y&=oKQPBXoi;xCm(L$(e$q;e6r^088pdx!td`mw5m;Phi< zxtlSR(hs<4s}_WTRzxb5J_lMFiYn?HWsnA9JRbpIjCqUPkbUp)7l9KUndNfndX1l5 zR>>STm-B}q?}UZUcE~ny>vj;Na_d^$(eH{ct)7%hyaFu;v;dD2WxN-}puJd13Ya$0a|rm@AqdC3KMwB+QUxeg$J)$)bus-?;8F#!XY? zUE_4R9e^FNk}gK(_xUZktP1`fhnu%r{4vYh0eT9}+o)A$3r6vVY#izjQK)WAwRzAh z*KmoByU87Y5c22CY=VI;vb(F)S*%s;0+aF$r7}w)%T_f{#M27!W`wQBHC4c|{^?$f z5>X@H!PoMORY|j{<>_kl+3==$6NOpAUk>(E%#26L1tRnCAA*Stm2=X9i|wpN>@EjvY-3-u-JKh z@KVt<#qDG}__}ta&=wQZFDPi3Niq^6aP$cGN^&9n=x7OuT*2rUfYIS@VAuzpYEI%wm}e;k%^{;;I22qFP})>*Z^!Vb5p zj}@Lr(Fxu$hX}((zR1BurK)jl8yt+@v#*2#h*8?B)Sz#R-v+tTG#Rg!hmfFVJa!wO z^}foNE%B>d#J6k;o-Uc!#2gh|>~4A?j&oWt6m zxS&16AY-pcC0)?wce+}&j!mzgb)zd`gDY!a2Mg`urk=dugwyVX0dK-Xz&IL-t3dtK zWRlTOhQX~QXijF01&NQA=f3I*A210GK_=o&I?%=(L#xN&);PASV@#Vy}yE{CB9SHq9R{tH{N=t1_mJ* z3RH%Qg(Nxg;*n&}MciUmbM__d6H$)%d@H1V6mk~gVe*pv=1xe5&CJIMFle1D z9Z`1E=*^Iwo%%Ii-pZt@z3pL<6b|&z<)gjfV#pob`uAra>mm-qpsnH0a+lY_N5xmtA_5iw>wq3+@5M z0J!-Ws2L=yJ^a-oIK8}u4q5s!=9aeSp*L|J3!ZL?f>K>A&jLNWOrQXFxU3lf1Ms*l zz5RAQdzEUcFj6O}up)lp9+@||5aD|}Iy8(TVxDdN zkd;_3dq}V%N4~@z4a}mTmqrZlk-(>8=%K81hd34m;AWSEFglAM<6Ry8OVGx_q%@%?wXbAqz5gQ!hyqo%Ksxu8Uh>iS|!*mJ32P&Zab<-YTmZfug!_oVED+*)qQ z_&Wu~!t{H+IAGEnH+=UYXL2L6imvpV9}CM9XXD~bK;>ETNM}?#Cv8Dk;PNRVBsrxVp&sGkw*nhUe2Y(nfRLtH#w& zY3SuXWF|acmBk3<+xfsp4-EypB*KcXC66=2X^n++EWhf+{;N_2xul~IIE)sai_WCh z-nt4`{|(|2K5kP8kF!5c^?es&%+KTM7T|kG%bj7yb)T()*ri8frr-9D7OGHbTf`Za zo$7dS7_JHo;;2H<-8K@lIuvF@KR-6bJu?FgimbAhtV$DZdnmq5dEH|!$n_g%PR~h! zrGud}W+i44It^lmA|%?AVqb^3g0@pUoYr1-dHM{uN22XnbSu^)uttR}iE^e*ooj|y zBT;YVbl=8n+jG$)(-B2elT}lSE>rzN9Er6)< zS)j*bw%PteNJ4^&pRb%7Rs9q41Ghqa)}8ym#FLpnZ=# z#)QDhC*tevNx4@Uk3|W;7r zNOGqFGxUH4d?j!~G+(n)(Nnyns}gB}NPGCrTglw5H4AX9#k4MYaa=&@XIRi?O|i5Mnp&2R_PLI)tKWb5)hV%j3N zfSGR~?GH9lSB6b1s2|!#Lr@|&B7sZ~z?77}jg+Sm*j!L7!Jo~qOxSxk`0C;9+qqcU z`5U0zgPn!}dw)n|c4+irZlKQ2#}cv6gPnQ$0xB;()G89JYlAAvq!J3;;#-f+&Xbk3 zd!3K=VoO>yIPsJhT$mMPCv%J<`M^f_VWu6gBFHj?{2^FD`^6&m$8D%*yd=k`zEXT{ zh5^w+>AhF{G7=i$13!rw1N+pmp9(rlhrfKl{g*nU+b;LTsHiYrA7#a}50Qd!tw_I$ zmo^VWTuGoqeYOQ=qQz*-JZ0H80Vx!8SNUvR;Ka07$*cXs(gw@oQIld0a}_Hie->)IKcH<*EvkeR z+2Z>am`})u&Y#M9Bgi3e%*%bR#&P|@+VIu6QRsylTv#&3`I=`m!sfPg|5xlbFLo3K z5aB^Kk=8Q+tLiu&fPr^yBhG3Y4!Kd&!keWtAroEKIbrLBH9Q`&4*};CZ+Moh?f?{~ zj&13CM)r|66*swL-}haJV2J*Adns^^Lp&?R)mBHpI>%lVXs2PYQ@eXx=Jyz%zS&4T z>(5l%2a+#c#MDDAxvalP?h)rI&yt=}gjZp2jI ze?ZrEW6uGS$p`mXb`0GwlS zxU5reK|L?_p=;OBoHb zLvy&dB4NCPNOgK&D_t5WP_(!-_oNWSX1W&Yk21NLK_#-KO zdA7B?68lzxu@7r9Qk5NPF4zkm>KETqBL*oGJ0hYgqSpdcP4aXeKeLUwQ(ns) zu)ckExi|q%At6KQ0{OOaJ)<0x12DE|O1)XOEEM8HU7vaTmpleuN~qg@Zu;~DaCV?K zxg1b-mjay4Sz9HaT23*^hLWp0yhU9|z0Vw(MzPDOXWO z>2YHkFk@UwCc)Z%%{T&r#EP`Oh^Mk@+1^-mV|&l<(m=1H+;e7eIa6@mQbYsT?-E%r zTRKP?P(NhNNcvXL|3T&DZ{(EEAJ#i3EBF4|$!Dr--*b!x*z^d5BIdj7wueN{XdvB! zMHX}bg-x0xdW$1|fN8aW1m}Y>NdgEIXE396OAOzrWv>LCz!K1foTOBrMcajmp1_&L zbLe_2q&_rTpvW2rz*St?AfAB+A201I=FfgfX1|pq+u3oKT)Hwnb7m*sx@RM7&Lp9U zu97H^x}J6R+5s|Qg^{f)pcrDZT>(=GffZDQuL{K;|$|zmaz8fCP$$nPo(Cg>;w}Ylj?k&UwGgMaRGfshS`9EWfQ+;P^0pEhfXb&Y`WCj0?~67edce zFyv(H^6H1|SU9GYg;r8{Wtx%^-_!;7v29lmIl7I6ti|>3p(kqTco?BBZTu|y(y*4n zR{pG1yGb?<@W^T5Yj%f7=!nz|%0b?8>1mD})X9)xx(rir2OL>(w* z($~%25jKTc1Q$b`7_Bh83;5oPfL7o>fg`(bJ4RtVTt>f=R~c=@xQ#j9zy648K^$!n z-!w=nbDNHkJWV3r>2&5=Z>{zYx6&$3r=>cL_o+}hNZjh&7p=qQ`LID_EGhRU?MCf7 z-go`AhL+sqg;>FPf(y{Pf|;UnR7eGoFn3AAx6*^02! zX7fffmf6P)Nf4+>3Vtb_pkXsrJn_)ag3j`(Z%JiT}Fhi_sM`jSnYEpqDw-%WJ^Xn(~JhXP%w5 zZ74hFc1}lJ@xw(d)zeiIQ!%dqZLM9mETJ)FqzQ8wkF<-)>j1hC6lSoUmdZWc5ey1w3Jnx zUI`>#ocV7-E?MTkoF7)1b?CR@fUXO@l(Z+j#bBsU&G8XU`iAODzv2PYrM?G$6Q#sD z(FD(BtT!l|{FHxyG-JeOh^LJ?$Tog62Z7j8n5jQ*eAxP*9{g|NjW* z{1u$8VU9Xh!_S^WS7mvAxMc4?8CKBNx6IS}Ep>#u z-7;;Yas{X0Ip;#4Fd-W+sMFcm=jt#zxTFHZ5<5)$_0K^cA%6-b(gC9|UE{7yz2-2W zmI>S_?{Z;VVGS~5eMxWk2(U!Ye>GcO7F{)3#!hoVA2Y|#;jquJE*C(4p3=PjIk`K@ zw%b&W4g&)^=&Nxc-j@|)%Vd0 zkP&deM0tom5`b&{IQ-t6iJ)(MBh+b^0i=P>rM=~rglbX_@wja`BgHN;2GmnRG69E= zT1;yp0Q^x()2|;3ws*T_?}z$jI-|sQJ@ATkT;6_sA1wAs&xgOmkS@^8&y7Cfnk*pP#R&$bJ>$%1C)h`}QQ2 zktC*b8!xaf+Z4bhRmY727`3+ok7GnqYWZFASkW5rT9w1%^ofKxg!-<7O)F7%=G4@? zOAto;wwP+0pcadRBjP%h`GFAhEj{j0)Pq*wo4Mw#m3`{S6hPm3yB3{}42M*swQ>2p zVlB{^(%81CZmkBZAX5>wKEY4nM(jO`5kOMy>3CtQO_KpUKN{vU$5RLrWl`n$4kW?x zXO-k9Hwb6LfTIN+aJuAUfKlDTy0{l!N*qb0pkT8?Do97KKl&Zi4V77IY^)O|-%MF~ZFvY5X zhB%jgxaIO*{1Y_Lga)IG@P76^dNP7oKE5;>I`IW(v}c*8Wdl*)cODv(X}8vF*vb>$ zDZ!qe14FsiHn9nWTv}~k-&g$D*OVw_dC*Rp5!xEhpCOZW&K<4ldEfTJAOFqV$hIypcTz<6-E4wVam}xrf;|jeok}@A!G5dGx%ug30zYUa zUmb3!(-%O`8GqKkzmj*l-0b@lw8qCg`3c(NB~oL+oU_IZ%A?CxIFbR-k+vvUfnbyG{~8wVA>`_z)uqDP1>_f1l{jMA zoKH{x8G2XS*s+Wf$X;Hu`Wh1SG;CQJynm12-K*wN>7sI+8XFR%Vp#FQ8lZ#4_l@4o zb=hV!(D#YH@wQ(S9B3g&SGG0{xhR*A_!3%FCFo##y60fP$e9+~p7nQK`Y$7n{S=L$ zqhAfY0MN1KbjzdouX*j3*xoS4Hrrm?kBKg#4E8sV3`FgsDmdYDiWiCd)sJU-=O*rL z(T`ZvJKQgNuYLi$QJcCG*C$zc(_7WdSt91VAI5TGJw|E*Cmj5soX4#EMHuuLxs~+VSuo2;hrvrZWZ%bh2Wd1dH!2 zW1#j6O0VWUqsAV}r>kLr&>40HVr!3;_|cyQIy93Ql$@tdH&+$2@LpWPh*PSQru}QM zGyI2sV^;QqwW1rHEbQn}+Gh$KQZ6V1TX@4SV8iWhL>R47kn3Y!D9W;aG%c#{m?HmF zDgBnqtMjh`JHAXtsR^?rc}ucJvCK4CxZ>jhuVF2tO**1?HA8WBgM>$_+S+BCGs0OF zs$EC0s>DU}&N%O?-oStoA;oY=s_G+PfF$(6Z>@ps6Y<-$KJa`aa znZ{U)!R!GnA2ftm&tUEzpAD-rvRNJ}WP0p*aRFLO%Iu@#1LPBHp#_@8pzAXo(O<|n zZNyK{$}V<%+TDUbVc-&@!pP-}{bb}3cTFwu>y#}1j^c-xL2UjtX}anp7^n^p^) zIgV_f1iqbMP)$wHmAz!RUXGsy840NZc~DLb#rg$K!{?NSBpCEj=99tS_-3!H#>F2P z)Y(5HFJMuiw{-HbJ)urdORFjT+gF1x)!EvAnC))ijCY8nWS zdCwpDIOPA%Vah=xT~bDfCo0Vj=N`^ZV!+E^Qt3_`U!H}yMR1=~GTe6b%Rs7y# zBUeuOVj>q03|Q2tmtXrsBM+pJ?!7O1e?`QowX5?7(Y#;zH#NJ~m$>^Mi0LYWePWcC zagD*3*-Ff1E|m1+d0QkL*G)+_tS3}spx%(x57X`lhm`{Gk zCRj1oe0LJ@=FTB-8b=~0xmNPrm+gVQOn5=KY81>Hb#tvYS8)fV=4lN_o}`0C$iV+a zyWZk{jcNJ+QzH!+V?f$(v5S!d|Hg^6n>WA>!}Ty=?UEn*&m!HMcco*^sG-!@?GVh( zp%usn7IEA>L9jLr9^=MS^1p|EZ-MH}S67EQDCmM!O>nLg`S-Ha zSH50T`{z$B1fBPvJH*z>L6^)5K77Yj%)1aKk;~ue_)Zn{CCe9~$IXK9sZzWOA}47~ z8{@i3)OK*z(*HejEBA}AV$heBZIOsjOG3UgUbLi}wQ}q08M}|QMQ7}L$ z=nxwK%!eO=sOoYDG~&i>mRlTnR#(PdO1{f?hc@peIA1e5yEq4(BA(KtXF}$X5~D5- zw*=XTz5}O;hQI2BqXq|mseS`HneT!Ws$LAgse!^ob5+mM#$ zCeQ(ahv+Q<>EdW`bFpE=C8io*?3jhrM;NGK9+Y^oH%|MooxWm%}4ZYX4_JWBf4MSMdjO=t)p{)gGyo=rQ@uYJ# z#xG@|73VWhq$>O104$V&I5cat;G7v@fKNGotx6413)E_lJEA8zavhL=ZlJ3(x- zzDM{co)ZS(G{FFz*8eqt(?Q@zSTeoA zwKneKu0<$jtK_E;pM%V(%fxbO1kdKC>6zp2|u zfl7kdThkFrRpfS^X(!6*Q7f3@1Ht0U5@^Be&w+5Ol}x@#94&4)g<>Gom#dTE>4^eF zuXjiqBSD6@u(&O&!-o4me!7Dym(U%#yL#ZS9@}V!e2!r|$>Fyz6dr|fntzJCB+4t6 zo`1oPc8Hwt{qXEnv!yyK;U6&77z9%bB(QSgy3w^q1oas8qnO3udKfOE2XDh0H zvM-SG+H?OefV4@s;`kMNHs|7>>aiyX(aIn}@z3X-Ev!Z1DmBJt`{VF>3}>7Sa>li8 zAOGL-_~coV_aE8j{DmXe?bm~Alm&Jp6Clc6jmem`Gf#4k-Df69gr=2BIF#99Vr)P& z9^9F7|AiJesO>&yE&9Sv#RiWBb$)MeFS_)RC-qU=lIoxyw-Ry zXo7bYsMkD8I*p0;`j|gFaB1@^jyf47SKX<&1l_hkzkr{oTtQ1AXIHkqRbV_7adtFQ zhi}}tB|GR7nHI08!>^s$VLYN~Gd#LTEWu7(hN>c$yU6qSvOYGa=7*?>J*WhVYCLz2 z9T-byp*`D!Xj6|V4t{Z@`WEOdhw%*VX+>F$2%eFgxSnNRWY%a%$DlCs#^o^4gikKP z<7^LXWXOhax0ue3iCzJCWw7O1fENTxRdW2DzXaUD{RC;^`dpjMC>-3kp8fZ>emdpS zIZ)8vpYPIcp_r_d7ST9f0R9Dr-?9!jiMiuOjtaiHf69YrFkpMq(0 zpc9mxcj{MNt)?>nnqFICK6Da*a)4Q_0kqATkpPQh36;oaZ_fARNGuDW@GAnCeM--* z>`W2XuneT<)A-}y^$jeY!M#1ieaE|Tu=~=&0{jm1t#8H+C5wk6YQ1h(?SrS{h{fQ22C*UOw?B;yz^u%EN(>w z8A%OkehW){lt}h{v8e{0ONXDWNT*$yl-yfS;x0abhw0=8M5Rs8pU-Pm;hw3mZ>*DZ zWo`yVU>(~OQq1mcaG?^>ihvt>TQ?gRgYLkl9ySPg0xW;!xEa&#f3Y{A@P1@rUQ_tx zl=0kTc&mnOPyCx`C%ko0#wF+Q#7AU&Ew8C+$GFc-^%l;in23U7-cc(nT{3xCpGZWn%af)J%Js|@GTRgAE-AX# zdV9?3`Sb4^cF@KCx(&*sm=&_BBT^(T&KF2E zEA;LN)&mcz%f0mzF01|rJ&-mQ;~fAzGj(z#Z!|pItbZQekm%I^V1=oT#p);1pN7Tp z{~D|*L$0@UW&;I7vCEq?zSi%5={{tjs$H?y=x9@#uggxX0bJe1TwQNsuQ_!R^SlzmJNB&W0q&^^i&nrq_?`D(R9SU4Hk> zbiov(VUH*`Nx>Z^?9q>z1buc38qAKH_t28?Xh!>VnE5qSB+&W-^;j~y5VUEr;{@i^%Nz4I&+FGFmWoRd!t(axJ~fgbaU;NvgGgrvcag)X9hc^65E?v>`4%b!Lk!qU8=FC*aA zYp+a7_5z?Qm^+vUj6jQ6kZZs4=NC-QW2;sFN*4(})#m8XR|QU79h}i_{Lp_NujP!< z;Y)~98`m4mgNd(_AsmM792>gSW&@c6nX!ZenW@i;c&-s1%Q465O9EjFS%3ylQ^~BB zdr@F0sXB+@?|l9K%z5Z87)wfCN-ZMw_%A2Em_~3wtj@j^>H6rNO&ew8C1q1HS^IKr&g3eTroP(|17!1W z(fQ@QWl3ruxk&}qJC1~XjMX7<(a;LQ?cR8S+xs$tlnU9FiF_(_PdV-~2k_m%LHcNQ z+lu(mnEW{_0o?vJ8%Rs}$nK?;H2(Z zcQ4(QWeE#pKzG;upr2Hn;Iq~a%V*D3XonpgYVnLff9>9v*@pS!qC7Z0Y{*l`y;d(6 zU>abGxiCfT>}ST(T@rgKCaZAHvT_e*AS+eVXL6crYY{Dk!vuixY6kZUiCNZOn7TrA z*pc%)mG!DSPca=AIDwhOh&+o`9!u`9a|^k8b_f3T2c|>d0t-z}Gcv{Z>cz&`R9)Y8 zzprw!Uh==pK^MRp?Ny!^2C!P5>L0=mOgYZ1CYI@`2Ovkhf9kxXNHJnsPo{%$pFz`Qb3^G{3U)vAblh=YweB>hFrX zYC3Nap-!rS6CzBmslMz%nI2c+Zka<%n=!Pc5w|i9mD`=%kqa$H?#pwBHc8#GWDn*k zt|LAGZ^xcKdgc0AW~k0L@8gv~o;BTOMaA8xjQ7@=F67XKV(x>vN0(0jnb&R%cu5-4 zhL(m9d!ve90oRo86Q5LwiP%G_0tk45IG~9C$*}y|PDTOtod&=R5m$=umh$VKy2(K~-qoZS!>PjB4*$dh;L? z{~hXk6HMRMyr8>y;PEbjvfL zFi}Tx@5Ptc4HxRqnA=w%v>8mS^^)AhH~9-6fDd5~dWC6An=EktD>{@A7wLnq{%7>j zOH-t5i(4}OjxUoA|t~GhfvZnR{a{QRL>?qa`*z`^3V*2ar1AAfh zq^%E-3l0HtZt)vOd6BY?7nT~ozJ^_Xfa3Tc6C3{-`hPA@I^8L0pBwq%L1+Cmsy>zd z&n=J!4ia-Q{q*m{C`K*zqLR$h*yZn3n+|^;hl9mU=#^7~G6?!~nrS+7s3o6dxv`Y< zrVemZ9Bjh)M$UWW|TlqjG zd8!iuufcjWdCMaBtkpjITIw1~g-&LxF1ikmp@uMSAD7}ogAgbMc8J;D-|s3t*IQiR zV-f<(eSKiGQ@ps2d8-%~OOh=?RnKtOWNAku;a36gWp zIU`Z9L83^`Nph4Z2uRQd$vJ0~oFvm^n(jFb`n=zFZ{4X|bLYD=HS<nHS=(gXA7Vo;yuH_B}d?(TG^y!Kz$eUh`LxRTAR z*t~kRb{ESX-k@Z*h!`f*OJR%!;hk9~-sfi+X4lY-L}w>CtS}mB$j*f?w~MVy(aTYz zBg|9HBGq#Ax|%^LPl8@0#BZ5fM4vxGwzC+-!hq0_L@)7iu-7%8!q})gIeX&2*Rw92Fu|_P4 ze}LO&1p;kfdwok0AIz(zJ}I#iz$otLM1A?7b-Pf8JI!*z5ST}g#13}Si#-SgG2zI| zun^>3vL#Kkn+eL8+R2QbPBPc`GIM+j4+Z-trNz(scs1(%9=L?{4trw{l8#VBU1@(R zr2y^MJ+#dWOgQg?FzWqw{H$5{qlfft@KeWlPr_`~$v)VxazXnYob-I3HRl}`+}!hi-1Io2vkeAnrttpL2WRBj>Ov7N1H!Lav%CX1#+?@TKQMVy$d0{BB# z(&K%)7+Hd|y3aDgObXUD-DXUu>Yp9-6Wv-sC_gY;*E6XOGOY~2bIt7jj2nq8G_~3W zk3u2h_YKv2JlyRV;X~iG=f*~S=T!<5$J(JSAeY5F|9iA=DKY@l#BUiY?CyTVfB&pA zMWd@35-FSC-%=pc5h`tP4xHw|j#hUjmUesrc=*FD!_?) zftbE2k&O@>y-j`*m8+8OT}jya1F{}LnoVnW9dHbmhm{C=Q{28nHZlZ$NPICUzOWMP zjR$!5C0~@>83mF-aGtfOvxqgwlBMPRN<{kiii^cxprxnGCsdDHoA|eWug42a5^5RS z)`Xh+jK1}HOQprNwR9d7kb5Zy6HUKlXA%_;_OhSAfCr(SS#q02hD%KE2QorKpn*(7 zY{gM=w$<#16;4jCv6N;X<@8Yv5EVSH%M(>7?{8>^{QK+wO=FV5uuPhoBqH|t4eWGw z%NC6sy1%+ue+E+7a*oP85Lmige;T##gMtBHF}&YhMD&~E7LLR(o8`5bsgn4_61QuA zTHfGbMmf7_oDA@Tkim_BgVUYqh9Wb2-NI{QaWqf*{bgL}QiSQ>xaQZ_#UMqAC%xms zf6m%YT*EvWiGvQVzoy@DZvO{EPVB196+tG*0RH+!ioM%ybD6echxgX(y)Y$xmC3Dx zM`tYiUhrTzadWT^XCXS`M>y=M^+BrWm?8ab81!n12sp>$o*Li;!in%Mp9cdTzP=1H zW_pZHN%#3-pJAV23>nggH>7&Y3FZM??s?i%|EB)U{RDZgYc_C#Ga5YEsMa{vDqi9N z{{{YCztsBh40*NM<2(Nl*c-kL`uOpq(8b;rMXzY%E~rvJpwIhzy4O^aOBdTTVXIM^ zk{5hn4?l5;sorCBs*=)N0tA*9&cw1KVm=FisD7x*UHSEDS*CG9iuauKt6%}qU4L@1 zY!xsOOEwR;&4Z^~k=!{9b1W~{p?>z_7~uU=9d-BkxkhUd>&cnWjLlk;*P_ezM9hG{ z76aCQsn497qsAS};A2bMus3YHoNh0kk94XkSn_Qx)#7EP4g*!e@0*{OaM>keI@ID2 zBSVDD^7!(P%F4{--9+DO2!Eb#R5}mv16=@)!pVe@8XjiZC$wHaiXjq4S>t5<@@N9H zfwz%yprWSi1%BYb=f+hrUML&LstABM0C26} zK+8`;nA$`i;Me_WgWx7~rTt#NYJB@l8v8yyMGC23M!~Gh$sbo-V9y4eEWX_e(@eHA zGq~lQ>d-sg3IP(mDImj5StoKJ^pw-W=!+u5T|tviI|bu=O-CmMBTsST?7Q6#U=sMS zr^H8F**)<+L_2i7-W5Bq@;ylCXJfZ$5M7WijNcV<{ueA3cUAj-eo5RbMP6mddb)C0 zh6~IA4e3HAJH}aIvT;?2dn~c*zitMC*32&8iW~}@=|A7>cg|2bm7WIJ|9!_X9N3#4 zlLQI9xMyGDN|WE%J2HQ(=A2H{BLzlEl3fX`f4dLVj%N~9pEhy$vF2Ox(Jne~3EO-F zGCp)cfp4n#fy2n@-&iqdbDhroQuDSnu41b%N07tM4|v|@o>PHdLmQ4~FDM_EtccW$ zwgMEhoGA6sbYJS=_oWwP_Dx`E>{}YjRw&?If5X*CgG=yvgv+E#-nt8c@c#&%eUUB3lNcJA>VcB<3 zGh5J+q|j$we}m!HeAw%mH)p;1iiKhSg(}@3fgg#rALxADZ33g}a9LZzrLa(-OoTv> zL{bHef_E*_>{meTh*p+DK8TpIcz6R0lJizu2mu{H3)4IWoN9xbirZ*a;K!F^6keaRSl@H((BVz*rRAV9jcu(s6;p^C^`N zLFZ}LpEt;|Y(7_+DUb?+)Gd_rE{!^F$)G@c=eG^Dh#ji8(oK!Q;|?RgH3}Ba{ryB; z<*go6pltktjaXx`mXDXo$5?ubo-1Cpf@SdgNu?Od;3Lz@xr#?IW%4KpbkslFQ6{24 zNviPr+J4327*N^EzUz<%u;~v{Il>imukx#N7YtjAff`W|n5cgo^SH4oAM2gGaYNy! zVQ^EynuY|Xdpv)Fj=bPC+}u$O@aA?Aga7prE`z4PV~vM-2o*eDe* z6*k^SH8AGF7U>Rt&>e?W;UjZH<3pK=;dDY7?H(>;R!K)rrD#9jaA)9?Q~yJ4IAiDsYgpHtFH5pBfsA7 zwZPqvUDrF4!JA0kT9Fg|+T#>r`|_svv^O8@F}j=v)P8ysB_LN8RGN1lF$AZe;zbaX zH^Db2&AVa4tlu6td>_zwQS`KbdHwr^E72bQY1<>j_xWCXFZg-4Kj>Wgs?2{oh>?VR zhqQZN(MjqZ-ATOO*GK6KhMkf!e99?=*D?vx+mJAdUfyK6ZmRRsUE7988@J5w zcNVi;N2Ap?5*Re~_TbS;@D)Y>x?xl3(wF|+giejl4N{Asgro60eEa546`!R_7nV~P zM$VRg18LW~zSbE~jdC}sMq zS2a_5#y72oW7C!jM^gDupGE)O!GDk7zt`aZpEgPQWv1779cu^MWeGzS@b29Er$-gL zd0cqJRa9U3osSugYJ7E%8J{tknuVuL2(%O;)>5{ygTpxDqhc(FNKc`vfv-ho=8UD-h)8lqzmtW=LZ`$TR_1vLW!j+pWvHPiIDNfGv_%Q3zH3vI0@Pu)nH_ z(9*lq%|_7Q4-UE5VY@zZ95p1>KOBU8-KYs?Ex#&j2H^xPIzuB*Zq6-$OMVVIV20^d z@3TZaP}qs;_PP>xb+*M|)u-yo{5s@5%v77pT|_h4!2WSE%4(Wzx#JVdtj^#wvX3#t7p&vI01|9Vkepx78 zZPQN08}hpJACx(7q;8!j8DZB$18yPwpQGi?;duRWo~qB!Vk@LZphx-TBLI5isPQ66 ziiJ7$FCqqjb5vH)4J*V!Pko?6C}Za}Yk11-AQbdW;xzo$AxFzymvt-@IGR7^%X*^N zNh++IHfd^mA&g@N&%l{^E4UD3*bbqxHLr>oV0$s0&O)X$;W4bCUbf-p6_oH~FE=fL zNrPt}hEj<{zGogwctJ4T`Jg=bLS{P&fGKf9s_CP`9mqn@8Y5mPGE=;_~qulq`qJUzY;J=?zhtKQ)kzXvGmL5mewid-@ zgq@NIlz0s^c@6mk&X+Zzo#$E8#V@v*)AsaF3Bo+Kowi_Xv>WRL#OpiZSH48^jc{xq zO5gf7n1DaY;o{RB9b>8~dS`xWB_bp7^fC?%;G$C>u`?YB1GVy21j=NaQ!`Zj*$-0W zUdq&ds?UCde34lR|1-$b3)o6f zsvnR8F{mMn+ZGnd%wX4*0%A*7f!MO-iSH+mCfI6UfK0`#0RVr)3WIx)(P>H8K1d(J zrn)Vx)1g)jVayoFz?Th(n`!}Z{n}|_`aI#*0)TA5ZN-90dqg*8k|<}mK{vSbygPdh z2SlU+MmYq|y>Byz{W%PH!|7j60sK2o2xLKc=Rz_+8(U|ebK~)u7#tiX@kHHZdq^>H zf=Mhn!H&YKNM_-Ab+G4sr3@J^^*2kJyXP>HDYfC1&tUv?fA-T)?N50>TVIKQI$JMN z1UZ8z_e$K+ieuf01pGl~6^@za3Z5of-(lZv1frR(1)PblrJpfFmv=+~2krlqZMoSK zbPR%AWQPALj8y0Vzy5!@Ftp-8@$JyIq^j$JGaaf{w)2*(ec2SFoOV|*7i&{-mgj~7F-znkZ5uBEWOM6 znL9vN{1Kbrc1lMdnzTHg_p`t6ocf9^y$ZQ89`#7f1=xO72Eu=;-yTR&JJ&$LVvlgJ-Uw7ihp~R zFiZm+nG+E)m??nss5J6qK(Y_Kzc-%=-cq!*bl!gV@<8RGy^VR&SZ>vieZu7o>|#gJ z4gO2{+n~Mw2vkMp(*l>b&+2^_cfQxmPjW^@(5Tch+~3DSjOKY*u_YAWU~EZ&6-d{w=+Q)L$ar{HWLl6`~5qbE})qh>WrFJGVVgWEi{0+o=mV&Q{B zVd#GaS?*+R`Jg~~PN2HaG0Vr|4P7};rQs$tQKxe7{I3s(lMm1I~$0%M)Dh^9NVbb5i z?-G`-xZAMcATT-i_j)3wMO%=1R^xjp6Xh|txI|^_Y;oC*%*FDQ@*EJ=fs6|JfkMx* zUTne^S!AR8jGng+7>5scDa;ZT)4z1wOZ-ljoSo1R`YP zG}Bn>^w5dJe-LvfD)7C!bBt>fqU93Qgh-&f%#uB;`wy7-f?yAVjtT_+j>@=DtO~H# zRqxh(J7$z}HY3gCKV3VI2TKD#JoozKN^QRJI|Bdb7dKyS!&$AXJ+_VHZ=SRCUgDqH zSx0-(+|9yB0dmZXf=G}7Qn*Ncmg1|lFyNa4QRxZ{^X!ATEf@Zz0zh}mle(`}sH8uK zYi|hsn&R3XbZs+%{PQs>3kO;)m8UaOTH^sjF9IeFo8U{wq!kd)tM;u5E|m^g7pxyv z#=&vc`~Lhb;;^Zyc^{2qw_=hCV8-%IZr=Kr7>d72cRjrZ(z?SQA&lIT^q@wpr2 zvj*?M&z_hv?;q~NU`)jPLA6^8^VnufZQ^h~y5jBE+3;@%W>x4S`}5r~vhld&X9Cq` zq{ApIHJ|C6J~xBVNFs27*>J_2|6pF#C zkXu_J@d-etSF;gMWP@HkN!&`b0YLItCK4onfJ-BC5ncp_=0CP7=sv83(uCEN_r{D! ze_EXmR7tB|YtdSm59l7@*SnEWOG=mgz@)d^2_^5#G8$VDgh8!0`=Qm-rU+&$nIyaxzgRI zlOmk*%U!?reOjl6m_7TFoYq_}euu5EI~LXJX#GsAVL+e-%2u9ne_T!WS9gFuNe{9v z!7q4ZS7Y*qqNl197lsyyk9npWY3@FzvY*T`%0znRI6gE$bv7SsQIx>q@F02z|Jahx z!iZR8O-|4?8;;8G+mQhmTBsgTqRvuhzLNq*4WuDMPJB@a!+SOFA@GB=ytt)!jWqd0 z7enH$33F{y7!kD{XELI+gZrrs6VS=ccwFfGr|gd)j1r`{D;SN&!^9n!5XHC ztQb+}+#i_>b@UGgC+hc9KD*0_DZts3NJQi~!IGjPaYYM{5f9SXg+&oIj2bAw()Oo) z_wrMX3=XZp$VwFOVbsO!U(#$>Nt6=!+SWNtNmqpw#?loS3FHwV^G7t>)gOMt$AG&P z5OeQW`~l5}7Xg5x8DS%6J(Pcwq4@btuuf-rL{bm$xowwGeSS2&Sxka&MurgPKo%5D6uCQMIi1{ z0cXtEyxg}unV>@rQ^1rd0*2_jb1QCUs4T##uN`_U=>HfqfBYK`1#yhf<#;ZWAydAP zv6g^?=OU4Ew@b~yb+YY2=KvJ~Qc&{N`hR`xjm0UAM_4VZ@U%%2+Kkb99>+3v=TprSeRh;ALZVl>yCobY#HtbN#j@Q%8ZLYMp6y1|_z*{qEz0>>3TaH}vWf0pd z{jEKW$L~xe${-{dLptDo?Scuz8u+JU%`%YfRX>a4vx%7F(-Fb)+HiKF_)OvDdgE<_ zs-wghe!8Lr^6IYt+DXRflzs)b3@=WKc*fl zozkoIXd7R4Zu)03ZMRrJ^C1NJabo<}T_1l&c*z@_WsBY1mH9NbQTCA0mAoY2o7nr= zOQ%{oEPT{nL=W(pQ=RkpQ{^hy#NUjqE<25B8vg;h2CVo@^`P@vyDx)Re0}(M%df1q z9bZA+*Z@rbRWS0i%e4EnJGalg^v=m4==1Zc#Mz<#_-#ylR2H}zaPxA;()T!#9=(p= zMvh8L6QUZUim99V!iSs}AXSP7m$E-5)p2(LXOdR9wyM0VRN$5o+*{9sXVMiN5wF zbBsKA*A=YJ_dpWBg>Nm-8AbA8ga7H?gTkf3pO4`~9I0NPmW>sRHr!8J430Uu-`~P6 z3vbULcmH(j7b<_NbHDT^X-UGBFLPIXR*Er?WWoD7ZVhW?Vf9;%7%zT@4D%su;KL$J z2vN@erCR!GhBdmRpllQ_kdnu|B=tl&ekhfN^ z&FZEc&<2|k&%;Td(vN4=5{3hmAy2mS8Z%hdh45_M5?3szCy=G&5r2 zBKHK8VQd5JK#o*AZYr})PRQHlpe~UR<1(rDGlAYai*hR^oU8YMlgHf79LkD>Mz!2+>Tu>0jiZJTaQ&Tw23mzeW)&XCu@ z(x~BaE`OC#)8cbZcE9lIqd5O5>mE2CVrXzq%=4}M$F45%gJ3jO|2wAXt6;Na$SOYh* zMNUCx4ZQr=qYT3IVB$hIZZ&VLDP`E7C^Sq5JbBSLF<%28a2D5nz*edEbZc){teW|5 z!X18U%^q>V$a8U&+RYh4Vb*g7-C1RySqaho23s&!WX)v3 z{fI+E82H`;5rgM~&Q97nuK6O1H27WW?Nn9I|Bkq<)sZL8;#iCM`vLU>((M%^G?yp* zC1<(^bxV%zhB)|?9MtK;Us;Finc?p~BAa7|$6_FjK`}4{(&D+DaxWR~u*Ix>CW&&0oA6Sm#G8RHU{-NJcoI3!l`rozMs@1@?X6l43hm zZSy;&nH(D`d3*yr< zt5ZI5ZFZshO4ui3#1*V3x(~|j+^j|om^tpzqF9+pzDkU=kpx-EDRG;&fp~evK_?Y& z2u`ywYNVMHJo}keOUk2-K$69jek+X!kzO44ObmV*-*pM$LX?quKe^+<;Ya z$kzL7b(I2(&T<=-2oiw;be@D6)8Q61VQYy?;VL%|b{LK9*%^B>mK+wR5zUK`^@47# zGS>PalNxv#F#3gu1d^dQwprr#v0m7D>|*;guT=^|T_xn^@ic&Px?2RY-&uGOBLQpU zyaDIi=YHKy)Y>NE63OO#kF6B7MJ{RvU-dD}E#P`@ITp;0P-&I}=RDAPQZpX^cLB}pP%23jL~F90PP)Py$KZx9mlsM za7}0bwIbR1XiI;o0;Y@H2d>1g@1Nw)AiDc=Zu(cNm$o-U#Jwc3VyXBI)ksS$`J4q= z32YYjL`eEf{pRSIlI{~Lb@+Px8nF(siuAY53jIPJt&$}{!4|;JU-lXOu|U(3xb5>U zwo11-Lhmm%%GHbFyr#f6EwfpyODmN2_GO=66QYL8IcM`xuaF3S5UiKh)wN~S54^Rk zqGyGVU5_z9qp&+XG4Vi-^l|go`=mN(;tu}Rp>c1%)YNp0NMducw+Bu5Me8p7ySjgm z-M<&gzjwv|q(vE_Tpg-oRY`*Xes8R<7gVI^<0c&)sFYX`P4W7S$lHD(p`eEsC+cyr zs;{d2)1<0N+MN-@lfsk$Xe@(DKdAD(=R_W-CXXT!=8HsxI_z;_tm34W_5rC+Sh(_e z$Trfs;4qKufv`bbl(KRss5lwM=zOi^B6PsbjwXGKH^CIdZnc=Hb|Ukxs_j*AT+T$M z4OVY?4g9X$*afahP=AEptV%A@B|My`o6XD0QaPR9f@}Unj7k>9->#*W#kZck0IKGF z@*A#sh5?{y42YG(>k^S+UeIA6?MSLmY-@eiNPHPNB^gFw?fYZ5O@`UcQgvJHADXSQ zhnak|`$9kc-MO-V&i=?q|$SA@+J}iJZX|4 zD-`FNrHb;;maU9a-J5sR;DoAv&n}uwcm9SVNbe(Q?bf_iRHqVt#w*(9_19R;h%lyR z%0$P@h8ve_iTF3$T}@V!{suy1AHqN;w=1QoJW7FI2?P8FAoMXqi6FVF$pZhaP)4YJrFCWJ9+!epj)k76EXdL9jPo+3AM>TR z4NoC&fK8g5s61tv{XGp9hQymEJfb>HI0W5hCRFDvw=&X{bAEsFLbN)6Jc9TW@IrFqR21X`gC$lM_tbvePLjNw@XzTS3R(R7&m503-b>$_EcCsfT}4f@b;6N?b8yOBGFu&KWv5d)tE;FBx#Z`rGX)J@R-s zGsj&3)V!9N(ut>g4gu~rJizq8$Lf>O`MGR48*JwWc%I2#eP8~yO7@2q{4m~YoSseB zKGyxnqGaNG??pd|D_EPIU1Az=it)`{Lw?VI1K+oaTI2zB!v_0IHFTqZmlA!jAiEzm z+Of@t!nT%5-UOiZsgmS0f+NoMm!OH1oFa6IO+`%pUe8z0r{@_IP;KA`jnT+3Ku~92 z`9O2$Zho6GZUOL)yw%Kjqdsl}BBk?ApxBL9tcx6cr`iQzK5Rl5pG4_!yYW)nT*Z)( zS&&!Y6di{srlbFvt)gS;GLWDypokFEyoisLW=j!%aJL5j5*M#Jd=e8@wf zwEkFH#HwS+czE1tN{Wo?zQ8XD{`2qj1`TOtyr6X{X%d{VnYpE6UN|bPC*at3#6=eym3jZ_P#bADFoUF z-uTa34z15!q9pt=xzw+{eZb$82)cDi{mwqnGUpYIbQC#F!Oe13gLV67*IXd4u)w2R z4j;;{rSP#oeqRj45I|%%?J=kC&G3W&2XgL8qtE0BQZ=Dt}cvu$fB=jG5HX86!y zc|S$j*Ogqr2hBu=U%=>EMvG?JWQA9?D@$QdK`Hd#(`a6c7=|tw`VLC%11-Ri|1+k* z9HkQehGVTtHDwO>EhUt3;AG47MIyWL8L44aPh_s#u7QswD{t+QDA*#DFQaC_bJ~{# zSCZ9iFH?J+fhElQu0qr22_C8~p74BSr z-(JeEp)24ebJ*Sy#{x=zr2e#K*bhksbfJ4hoSe^_v|R5Ba}L>Tpez4fm%SaNfQYC1NF2sA8CAG7@KLY$KwA0`k956LG@S?qB+_Ffy+z z%@&JCUt}Rx+?5m$0$GO;A>FYHAV|9DK3ByTUYZ2S zS0yn7&aT{0A%;_>n^^BSLkP^BK0f`%<|-)zR7ZWk_O_KM$@oRZ(%uCX_;_@B>0$rl zyj15q(n3ReHcQ%pTFn9XO@;-iO4I0RiF;@>fZxZgdghHnP(>)W*-7W`E_L}hV<&>w zp^i3NwN)_B{Wc2nXrkNX=gB+N7I(!w5DAK=SC#z`sDN*TYHd<{Z5%S|rJ>}-L*ToE zz`Nn6DZlw)O^4ZLbc7aC3++Mlg$xb;@4jJmcLltk zMIIiE$@SVYIcDaZjheIEUuBen;;7$0d1x-1OKW}9`-d2I6X$g#4v;=y43UoK#k~lm z)>#G%5Sl=@kCtB!h|mz5EA=f7Jwt83=X${m4+D#k z-}OZy)oeiEw&@$w!XX@eUTh1Ls?Y&z|9T$P%@R4sP3pq>7-?V#(xj0Fsq>Kzc*vt# zs9>l+mi^J9{Gk<5b0FyDNLqs#X?dwNpNLb&k>-UdJ;SVxsYykfDQ0a0VVSktbS7SI zwyVh?QUPI&rJo<^F#AqN>B?C`F`TNAgorWjL3p~$uc_V`Zk>g64I;1%D~VB=gM=-> z^pfyY50Wf9%|z8`R^D{~FIOf>ZXwiib8oL76Bn38~V9a63p6hoSc~oO9bskNTdJ zg)<|z#NXaL0W;hw{$rpl{x=l`t4HE#7>UjPxJ(H1Y$B~<L!R>2%B&vmIB=xQJ43&uk&m_Y_w=DsU|4khQ38>tOT`R$9A0u_ScCXkdEiAhV`W!nW#X$0dbG*$-Egs>ojBU5}38r~oaY(i1mzuR2>kcwvH!ScOV zSt$zfc)Xf3iT%YqI|4~G(MmFTe6pY^veNuDl+r;H;TXolcEwAaXGV zvTyQOu6W`3W?Aor#tZH=aET3xtsc{(gfHf9D@s{)FkZGkjGN95O2x9`{+L&E)+su+ zrq~Wn=EWJSe^+EyHNl8Lqe3$+_VS}&i_d{YZL7g2>E+5mEw*>n3^%#v%8v=i#n9xD zi0c)c6Q4%-88hOmJzct$yz@{14%$_AQ>Zx}72r5y_mkDY(Ww4ITgOzFN@*aT>=JEd zdkp#-CQW#!l=TS<&|W}y4)8$o3?EhRa3gr#Y7OE^8+hX;VWzp2USB^QllF&f(y2hl zV6L-YN5`QY0vJz+UjODyytAlMnIK$fb5&nn4oTWjwuxwMJak z;mtC!6h31x)u&l*aoG=2m?b%=G1Itcq!#G9@kM*!HdtRAxYcM?^EWWsjCiElu+!=4 zTcoEAcl;(^1>2Z?y8q3O%&sGp%s-A!;EeIIaEtPcg+RN2n&1o{EpR6vm&Vi*-tE3Y$;Rl((Uep$LE(9 zuDpZ;7#>!Kcj8iGE;xM>vl6)mHistpWfAH2^uc(l+}(Y$;LwWeW$f5th;AOqy>5zh z@-*Qku&1OH7EAAg?$HbBAxY2mQ7+$fHy$Ibo=o*7A_Jla*U!fE8Cs0Sv8~7g*LI$Z zhy&f+--Ny6AFrZQ&o22r1Bq<%iqoIiqjBfLbZvB+&82JU-Qu})E9LVCjcUOwGm+W{ z9bfhKnXdYesxiZFIk>MiY*+A?oRe0YxL?F0x+RLwsyz=>0X9?77CC)ushA%1)hd;M z>}qB*N%bg_)l#LBA-M*7!@1H;Cj$-v41b(2MK_}Zu2;6XA|3^*`Ue88bAv>Y!2R0S z0lb(Fo!eQp?@;mlgG-Msr}E1{SEJM7kI{}H7E-e{1a_7I?A6izRoSx~p-eU1dKbNL z-b^RiRiQB*avY-G=jK{n7J;c?GZan$cq8}#?~pYz(4#1c*N`jev+xu}{MX^u_>7gT zKakx}Fy1R99YNc;klusIWqOaupBP+K)+cN&Wu7#ZmZG$u+mEpFm}XsH{2Mx4ezn~Ry-(t6XFc_| zrN6F|R@3HI=zU^vAF559MG86ED`b)Y5~m_Pr`b+@Tj{*Y4b?4BjZAf4xc_xlKp4d1 z6)fM7x4QVC@`KUF$^8+7n*S3tKQ-uTSFj=SIdME}=U-TR3|4Y3?V1f6)X#<~(gsL| z&Gl&IOKz&6G!f%v06#4#jqD&VDKq>liyCaWD;kOJH8Q@x{s;X3=j%o>H2;D8mw~%T z*w(_-ktfI#Q1KasLkqi@bR^|Om5$fNNHMA>?i5}p9~Cn0;w1&LGKg)ia${O(Bpu94 zM{Gu+DTzhnERJ8hZyF>i-OShd$@j`f5FjkQXu=|HUp zHWgcU&7idH_z@-0!>QS8l8&RI3aoiPL>JSBI%;b)+OZ zt3ZUUnZkOnB$wSV3n;j4XmL9z?w~KDb_vRX$U{FOk7|OezDI%Uon!CAS?@avauRQF zc4)(;gP9N|fSXsh#L=Nm5dDy#I{NyEPSku#EhlZjjE5v~vv;OJbjJU=eYyXM|yoS1%d*1w(ws{|!rLjkdM5BYFq zI3d{pMQsB~Xc$r=w!Px2UZzu2c5G2`*84+24Us1557{dYFk2I9XYiY}Y zwY=|)w6_RqrH~`8y|stL@M$^5We`4X1=;>I@<)OI^GEXf>#U`R3}5nxQG08u;k%T) zC8)}q05s2M4O~v<$dk%^dfvgMD66&620-{vM{yY2DY?lVI|+C*4|?y3-8w@ebcuqa zNf-yB;*24?Wf>!o2rKD{ux1Yt`-q<&AoAn>9r21lsi>s83Xk*>H}r_XEegmC0F&y! zXgXnN;Q;kVaX|0Ak0nbSQ{BksmN>Mt{wD0u@p?A}zFu0Wk^q!XGozM2^gfRbrYJ{GU*j z#=puiG7{ezeIX~30B%FIdGsZwIrLV*@f@=1Yg$|(JbN+=}_Bj>h7_$a5u@|~j;Ad|`vGmm^D;E#IFfrHUTcxxMFEQ7tW&()Qr~MVI z{=#(FO=(%PAa`=&EX13kNO{`4S@A9Py_C<(dI2o`FEs$ z$v)En zf&V?L4sOxFcICW^OtJw&e=&X{MnSTgS1#>TVdN%sA2KwmfBsM)1`o6I7gwosUmIRz zPc`6#xOod?UinBOq64lBNe2$)`xw-Vp;Pu?+Ur*pSB%WUrc+HsMr>o34)=xM6 z>#aF2fA*MGLE`Pn7|X3-;=mNh4OZzljCBn(ype=MeA^zj{SMYuJO#r)tdV`i411Y| z!h|9FWtiK_bo7DTU6)oC_Ai)$bEvwVkFuq8DflSZC3xt+VBT-S@A)@#|967Hzmqfm zor&`QNZJkCj`AJfUK+Q}iVQN1cJZ`z9U=(>E?}J^lD_Jn%G|9aMes?3NzVU6}wk% z>ueEx26CdQHKyjeYS{R$RcOSks#mvfGrJ+a0STK|ApO^}#YVU}W6|!&fKp5~XBQk~ z$T>D)xc^~Is;-CV6_i#{kfyAgK`0%U`PFplqQCNUt28acq__?n<;*Bp%^P(al|6xTk>bCKDZN-ht#bS{C3)Q*ZWVn<9 z1?WT38EwI>H%HE$K-7Zt3;tscK+sJNz!#S_DqdSVb z9ERy$b3e%nw8EpS^HVDu>1-4(5nM!F%HBj)s^$CY<$~|MZzuUk6u1z4x{|Jz(~^+K zki5b1(~nu-0vP|A(*qd)Kd|q2%53huqK-GgfT7q!BgS#1||!Kq*qylOqY&?<11A4S*NopI;R?0z;=8@F;Bc#2nF zWdZ_uKe40Jq*HTx-uSb(H;DpEQ7N7Bx_|Mc843aZ9j$09w?D}Rs84{O=O2R+nI^9; ziN{~XVaz?}_b4jAl1_fPZ7K!S4R9n8i<)DrD)td#J8~e z^XCMr;YX$)nZjhB$HUExkbFG;%6Ew_YmEwms||z!A-NcUYC3*LS@vO#(Qm8gYH%5x z4%THplmxI3Q0&?(h9CzY%Mw@A<|^AgROPVfiK;YO&IFaUzj5M0s-F({tPLqU{)2}D zsxg3|P3frwlh;^maV`oVQGRLWM5YA*?~(#4y^)0g)hAIG+!kPg_lQIvKg2%pK+Jjh zm08@Lt;vI=KA|@>HJ1vN5&MD8%)+CMoC)wM2xeyrdF+~&02L7%UtTVg#dlz~kcqCZ z1OlrS0u_Rs+QHnKwZ`0o@*7;2H-A;Ya2eSswu9EF&u;yE`lw$CHVB?#m9XZCfRyRodFR30T= z*}{vZ7Yes1=r#MJ$e4`Isf3~iGc4{4L{6125wPveG!2Kzi6VW_Vju}M3RvWro6us+ z9!A}V=7D~|d(#paT@tPd$rH_?RZR8mhd%#EX4gtuHaU=o_wr5Hh819w>baza&uD7xzWSc4ccSi6zIt0GAaHQhTH(vZ+L?Q5ePI1P;4}U@6d+s#n+$qaonc+22dAZw&gGZ8<>W;}H zSwork?iaQm!?q%%TzGw%ic0j%pWsgBv%Tt8_4)Gwr(U+YuBp>m56I#R245|^er&-v z*@MOf@~>o>H~gF3Okhqw+}$-!O{JP17y$_ZRS|*2XE>z?P~2Q&qJUENOG|nI1U|s+%pgLE$S-}qWNSw9!+%Lp8zlO>7HwA z!uJcMD`X!R(h-n%Cn%j4q6>Y-0zD`v z-+5o!o~2->r9@BV<-McCP9Gg?@Uwkf%HWs&LE)y}oVNogRF_jit$>OO!q2?gwhY;u z67^HCf>`bd_#~g8P=9-=E$X#sqoN{4fS&W#g74FK=$5fVNMP-na+yGJmL-q@(~by3 z{F67aTtMbw;?aG*6wW?e%)8Ip%U$|8hV_(Gd=K8m7#6*ymgm}pb}=ftz&eAqUEBDY zZ`1peUD<~8vkwcr{B?XNjDD7Ep49iIX2E<<{K1L7%~&DO4TIhRQ&mHwkv>%*yW=(sCmVepUG;9+ffD5&gv&D zHu`?|EB_kMqi0$fSe3;U+3P52P*EecDa7h)jt#-@q!PX#y@Evv{Hl{!woGl=is|L? z9~0lj(W6-2!+h#0>!AetoC!UM>W1DLK$-vk`)O;Lz!uccmkBFfLWuefS=3{OqNhcf z7cJ~0EuZcb@1WBc1xMcwMK6y#fuu!cepjgW)_cW5`1BUeFXMW<$ zr%D$;?Hn{)x4%vPS`j|PDw|HDN9?&~UPcnUIcx0z zc4~iWbk=_1HE=!VOMG7 zbsd!+B`wn5;+ftej^Qjbi^o00Diu z-Vy$A3x0OG^l-?>gCA=y$)&lKlK=aD5XaHOySaB5%g-Bx;PygTO0adV5qx@486i7# z4W1FBk_4Wf<_gMZSkd@<{BT8?1@QMH@R}Bms};oe)V@RKbR7b`Lg~B>f9(RAiGZD@ zPBvNiz?P{%4h`M(%N-Q+ramjQR6_6rDnz&EfHX+>7qF55vPIH)@FVVuda@i*AU~hK5X`YxHUhbzlST_y&?!FLOSd2$|O|_p} zOOQP2)p?wY{zFi>W0vsDZ*A~N6gX|C7V11B+U#AK>PBW)vsoj&e_Q5`)q&zEN=M8w z#l*$pjFSe(kN)mJUfIV!48IGB-fqenE}d*o-o4x{x%5kTfKU+L%;T@+Gekgk-70L8 zy35x-T7ieny!TUS^)57j!&*xilOBY9{f*M!`Hl|)f5YB~B8*ryxVwXPC&#z>a>HN< ze02ud2%pG+*Js?tYQ-w+;=)qw11ne!R5Ps6<&{B*66{!86`nj73o+ z-wbexwG&7F8?h?Kz+=b`?PfU~>r7SfFG==pG%!_2WUu-VBWbBqtuardeF`#NKTxmm89xgaX!3_coJ9`)56b>L9?J0j zA3%puQ;AV3yAeeyB*KUpRJ5U08%7b4ecxuWL}g!!kWsc)vhRlM#MrX$W8ax!_Ib|q z`Fy{>^E>BtUgx}y|2%Hb%yaGc^?u*i(_FKX!lRxheC1)@`IS;E*5otOYt@DJS*pA0FpN zypr$FgnAnunAtFAjta={j(^vM*s#MT-G4EGN1Wb$A4SsLor@)IE(4Vnw>T%Boe#cz zJw$2__ptLHbIa~&-9Ldy{zof#e<4McTcQ5%C9PEBmp}SonrZD1YVXVd5^zYjy!xAm zH)5~a|H_nf{maXh+6hFi(9}6^nX6gqL$?JZ2Q7TYX{&a~DtcHRc76shxwxiox%KnR zt%y@G>B*t~T-i<~Ol0UCTH$Zqt1ZDJ$Y1cENB?lhe&A({<^Lta^qu2Tqia_e`_Bn} z{b+z|xO(Ws9r4vukUNBmqCGk%rjPJSTJkWc?4-5t*TrV6G#>6($a`G4dbU?5&L8rS{x zspOrDuR!5(vj2UeER2U;dxNI=GpXv!a4WlZo_ujQhm4rwn}E=Q{BJ>KK8V>Xk9`u^ z%up||$s342p!k}|SkqTq$2xIZ$`w`W7=Twk^NgaFDx0N51)mz`c zBeQ3#gAye>-nuE776l4__31wXxq)@LP^Ogfqv!`&Xv&eRoP+gi_=Dvywp%KYg z;aU+-|1O>hH6FqIPZ%kq_je@!Syb0=++D7RX+4fOO%S<^`3}zz&XPx{zn6^Fz9F#m zkw2i7TkD|p{@2j=*pE3I8RUk!U0vf!)bOoLT(6Z8JeJY$#t&6{gNqT&4}$LpSE?fb7|e4QK{=9P|jJ-{QF z#Q7B|x<{#R%4{oS{z4S6N@dOLi2Z_Yavk4Ss+ho8)Ejh;2eWLXGSIkMEt@U#upsOG zp_kIY$#}ALwPWM#K>oc?a-<+)fFtPbLzFJG#2|qP?uAr@cz#$(&Ym)ccJ{+=?guCo|~3~u)vbm<0KirfG^Xu z1oPtIq)UGKzxBSZ@l$)=F)DUKX}F*KEkZNvU$7fBRI$aJf+2Q{_lW%vhPkF_^Tl{6 zUT_eFl|qZtJsO%&9N8N6seyRn^r|WT>OAeYbka}V0_S}iFMhizjN)CbW;^{{rj&?@l2+^uOdX2UP$kA3zM%d(_6C9LXg zbDNX4mR1jqsKusC&*TSQc~~}KyE0wap)8^Cu;i^6U)h(3S(8~qgQq!Pclyn&RKeMn zVq3X*hz4Ja@J!M>?CwN>%ZHXgAGW<|z{n=k)IXkxeXM+N&;r}w%2`0D1#U&4cKhbq z=*Jo6^Bl^X*>^$!y>YE?cr}%=AiSMhG|W+1@Wq_P?hW|bL>_OP^fDfn_MIv{7`j~-P0GQ z-~=$83Zokw#1~?m%iklS0y&%6D(Kr=j*{AKQ1s%Z1`Km!^2$ZETYsq1DXu~@d9BzK zFsexw>mh+^YSW<9SX~!>^DayAdRXY#`PV#Lqmjo?z8%cIhM+H!T2siHcg?Y zD+Bqav}L{OF!r&~myQOuN~Z*4xWA~YyINI@rhN{BcvbQoTf46C@g_BR@in?G%jc7| z>U24OJ`&%e@(p-D>MWJMJ*xl}vG6=3_%Z|1>6xF%YM8(N*^ngiS7rQ$!aTl*`e!lr zle*ZYl!-RE@^ZTm`yktKHEIm4@VG6oWnbS`m1l~{{ zKCBeIlpPsl`A{^E&Y^}w`&fjnW{Fp&(}ofUMbfd;o8>J?%Mp*Jkz(L_1@PAU;V3Eh zVHSjq8?6gl9Qkm4tfME&)=RiF=WlmQ7Lt{&pPQO0%xSbf@Z%rRw}zL}cWH0!{5CLT z9kX+LmjpB_AXJ@8hi$v6xF6Gy|J!VxhOXlqlKAQvqt^AuWmy(g{e4>Gaoa$#{~mKd zC-241Ao3K+7hnR~onUmxLO7E3G}dvIocIbx~C;F{zg4B{{CQ*=BNJh zJm3Y(@R$z=uEFb?ol4|v8BciV8?y=AxCCY|g$_2)QQhcz?`(~~e{^{s4cj{wq@nj+ zVmQTYkT&itjC~AQK(2!~En}gddGNGGKn&|tgd*=uHcRv&a0DTn!EpzpAJug37|r3U zlgewD56y2rywIzsdUi@3VHj1}2+@)hT>(|aa^n_l;^aP454j!udJmy&pUiru-<2D#vwJf(tas{!a zlksRsfZb*q7@rQ=MCc7-C0s5uLCouErWYY*v#f^v$F!v7MqUl&@8f3=XpICNg>y8% zeQ0mazOVqQ1v&vB0S^&{mq3`$-=~YD=2!ecn&t%9@Z}BH1O-fQ70JX)+__A^>+Cz#9%=dYxl@PH0HWDpH1=?g<`=^ zoso%VhPT7BVaC7TyaMxGY%M7EeeC(`k6oAUgO5MqeLXFbYpWv)yJKVLGGAlIOOP1t zi`d=IQB6i?8tTka=lyX(+WX7VQ zWz_Rb(aU$0=wEbced4}9Hc0r$68_x_n8NM@$-s83{xe3e?`m-8D*@7&2a*(_SbNB$ zzb6Hp=xna7mi6xTGoj0mSXTQRUqWyHU-b0X%R4Xwtex@p@wv-^<*(1XoBa=Sz0!iM zI&-koGeI;ly@LDiFRvi&TsfnLf$XFckfD-}_Vu&u^P4}ub$*Ow`RxGA2eqv5`hW?Ml-pG7r(4nV=U!ONv{4W{) z-cl}qxcs9BtNGZ>M}w-ng@;T)Itw1iOeTm7?c%v^l&5h;&EbkU7O;_S(j0~SISB47 zvW!9s{J4-qLh0r?Fu84)vNnW_$F(z=W{o>#Tlm23Ht9hWd1O%Z@rtwge<=6;Z^e;< zzP6%QYbCk>b=J-^7Hw&jV|fe9CbB6N9GUkhZRGNoOdIFS`)1p$B-4!c^w%g2?IH`5 zsD+)7lkMzvX=LQRI-TV_LC;QX?0L_!jBU%yCvnR+f~s@zwBdOGU=e{pou#Z+ z;h0iWyVN(f2gAR3J!iKJ9wc_;eflf>IK11|@cNm|%lw}mSWlyHf0l2X{_mlIN(*KS z{ zuf5?IMjt+sK)y&IdCWVxU`In;PDbNZY&FOB8!Uae@mTDn?r{ev3oLL&4Zk|O+PjqL zKbI~ys(#=3^g^R+X<1(J@`r+`&2b}wqw+|w|MsynDOvTjD8@%`{}KP^*kSX{&mVZ- zj#;IM0pn=SxO<0^^i|CvtH1tU?7Ls4n%B&Mf8E7HPc{V}a4vrIw%Sxr8yGrn{VU2f z!QfuV#yUB_IbXQ`Mw*<4)4CO>FZ>`wUYhWA4YE6KRSF1RT%A&#vNw(Jb8$c8$LW|{ zm=(#_f~4`J@{1y4?xx<;sE)FD;nU4IeR1#*Wu$fGH@9FOc*16oI}F(c@%hM@IVBgr zh?tG9rs!{iE@Dgqz}|3CL7k1N(jk9HkZ^vA=ZITNOv?v-*_+Qlh$otuhF{k)y12Fz z$jOf(m7&gW@}J;jh~+zlIB|666yv})uT&fq^GGmO?1tzJ#ODvoktCi=O26iYfNAU0}0Xx*{_~ zNxFOwJASS5c5UEs>aC<^BP8RtPXsIfZpigCxlZ$y8yr*Xm!w8o8G->!1gx#8jKG-Q zv@7J`EixJ8H=Q^S^eskM2L4bP1Y$#WT+~V2b`pWp`KrWV($bafQZZ*n;JgP9B(1n` z0Pe>7$&Bts6bfJrMmY6L-uoQ&+5rD?Fu-UQO4yPhT&s1JNG`TE`K=q(DD-zK1?#X+ zCDme9-y_}krv1HIK3<2aOm*d{EAaOvm-yoH4~c)HWI8oIw5@R4(4}stX0cwDrmI<; z`7CW1ZHtHaP91~xW3p}}-cx7SJg&442-QjEUVGA-YgRVm&=Ci7WHkT`=9WL>LhR{# zkCvK=f7H*c1@kLQqISL^VM{JnQK`FlN{@gjA`%Zqb2-UzzNO>N61i@73bx#w2+r0z4IBOo7i$9cu0H5aj*JY# zj@zJhxAvR9SaeQwkM{p;NMEPco^g3yxEe+|r-?BA890C(lw35;oZ6icsd*9DC?~DT zS)i|<}uymUwnlXQxN!7B{o?kX{h4|6nu8!5G8b_<*&>A=a zqm{ZHlp#KKivEiPTRpce`*Bim#J}UGCxXRBb_bSET%MivEY_O;E629DRkrkUbYa!G zYNvE-H73v|u%6#i#^uPCojI)WaDagtD&Vc*6>Mv++VwndKYT-*~zGJB$l2f~316Rx^*pz_|kPC*r$!Q_?) zHQVnJ!RcDgh1}-u-tQWs8-B!q+k!*U?sd+j>2O#cd}{tZIOU54Hu~w|+*6o2VojcO z*?3OR3-e<|3p28!X3Wb zg+2e{D^GQfE7oL={ake+*jnQY@*juZ|6~4k`j|_3C$O{;-`9UI#ckAP9$h!t-63)D zx}dM#ENGjK&G4EOC|)O78?R!g_lR^Oa2}vFu*PuWE>9wO-Ho_ap9c2MMc1WXfQ;Q# z?V*rZNutdw4;ZG{)Sp|66)s?U{Y+ZE-*DLyVS4fn6Lgpg5$;z3c)K8%K^x#dW|T6_ z=+$>uh_`pBB*OJwo^Ku@0veL}HKpt~!Sc&T_fHtWO?P=zK1u2^aVYvb6t_KHbLto( zkX3|as*ONc{HN}rgN1I5n)7DYi^;(g*A{k@o3Ya0SHUT#M(`KRZQ)ieNKqIKGy&;O zvHJe=xs)s%G~X~Lw&jQC7K%knFD)-YgX}q5{I}x4mUZx{LzReJk2w`+Q%}^LuG^-? znUM-TxkYO!E4fAQR2UAi`?|WtzrnEL37eLSX(yZY2oT~ILqv4d`7vP5AIgRfU7h?eT3Xw*5 z#u{7G48OoM4ODqe<@pmWekA>wa`k5L*1KZpP`Z1ad_36fwqSYqI`|Z%`q3^AUdkmW zxz)%8TQMo8>i7mhZO1Yc)c;`)PCbmtT?j_yb(4K$JoxH+>##tFl8@RefaoN@L#co8 zEC`{d9jZXlJfwi$sCvNN4ljE&2t0@yoWY+K&KrO%O~H85FpQl4nxj{xmwrgZ2 zA&oWlzutaSer(qtpx>F3KPRaNLGIf{gQ8NAD_sj-&Q&5=q#z96L1Vq3M~4`b)LJT? zvq|YQ5#gB&lAiJ{#+%F6nCIov)l0>)`2y%pdI!#!Nq2R#yXHPtTKhJJA*pO1l5RKhU3y9 zI<$K3R*IH7$NxjKkBoyeM|H8$_q|nKn6MNz6!Q6q*gub&x)Y(B`RD|O+O}k>= z_`COjeM``lD|;_>M*5Ix`Ggn8B7%k+&slxh|E2o1iR{m(rqsBYrzbDLcpXOdWvJU8 z!YRWRSr-N%?Dr3QRm7fUIg3jGs+0;xkIw>2d+W#C)RcUo7gx{ui8@x7YEd=d2<+%& zu-kfzk}ij$fRsXQvP53s(1pqU_5$ zc1{;}9gv&~k=IPV$K!P{{g-%ANb8v*hH=opn;o1Brw` zWIQ$S_=&iI@~O}K%|?jrxZ2GUa@k08!HRNKG?ErH!Lq##-_K)U7nXCGuwP-&s(?*z z#;03S>Y)Y`n_&&79_97A(Y+i86PnvJCdL*nwT}4Nkf=685&jCan+nT zZ&2BXkm}Fzn*4iL)>`t09_wusB3D0E%=qm{)V8*daDQoHd-qbKe5;1%Vf(0^UlnV+6}Ah-Y~>2;{%UBGsUu# z5DNa}0n>zffRc-p!UMqznttncZmem<1xTGJUsibAkp*KjmvgV)m5qB}+?brnnSUn< zRA5KVlL4t<{6h!)u-b^R=J*eIMidZ#gHUR?MWvA@$7dMvvmoi`~FQTs!#hxM25I-UpaNwsaw2LmQFw`fFCPN*mZkru z0vG<|sa}7%MV!fBnqhEKi-@McUhOY1tO5RH0AgJ0R>d3%N>1}%{(4+FEFt*W!$!Yo z3E!K}869v_5;A7`BbM4VOX6gF@T79EeNmci9R=R&NtW)4<~Mb~Av@+V*s^u7mL_t8 zPJH6aR;hl0fLO8Ym>UL6+y;P?He1VQ4Em}MLuPiTSiT#L z`w97y<59E&8NEv7(SlXp&Ed?>V^Z(t`>nm4%jW5Fb0DPw2(}_-`d&-FNmGi}W!$?Y zm^!&+-h-r*IW%ze!axoXw4G!1mV2U3-tl!I@EDKXR`6^Ew4Ae4Bud1FiAYYL{fx_O zcsaDYBXf);%X(S}{k0SKcNoy*wy1usdl;|tMbh7FfSr+?O~0)OP4}xlBMM2hJBpLY zI=OMZB-(ixPyzTTlYf65=ReQpqMX*;xV?Z;+yEbw_RqUHkH$4MFX*B+_FR*ZJr;>9 zgiZzMds^-ixTVj6*ZB=_R?LNNm$QL}-e#lDeeN$J2yvsAG*{YH(!NnTbzqCri9hzQ zntz2!$aQS_P2%Uln7m^?n;3y+}QJ%0oq(f=Vz=%wzUw8v51 z%?cuVLk|8FkKT1-;`z9fY5~I{Zzy`-KkJC}Kaze}j5IV*w-SRsHC&OJQJQ^k?~x^| zSf|7jz2eze2L+8J?h)tz#5A8~7hRjPMO9Z{j*0CK=0E-gTR>)(UIkPGRlYRwbnvvV z*qu@No&S?b;L2`+r%V_-1elVN^k?r;0uSDVXN*D|6;%4~roHEgv|w{`MNF2&rxA5j zb>pQdZuYk6qg4&CbgVet9v4Qc=$5x4-c>_i2uFVVGq?bX#Ck{3Dz_1O?l{Hd{tA@5 zT5|!PW0e4V(Mn*INCe-zm0dBrz*8yzf*Sk4~gMSf1t!^XL97jU&h1ohAPIX7;2`-2WKy9%5IsnmgYn01f>4V_4*^9em7?P zS3D21P;FfT*LnEPpK_i`{DS8FAhZ(CIf>A(oO0c~V0CcNdoj_f_;%F!!v-7E#&5cA z)SYq*V$L<3lG9f=J~G^%u}7Ps@vUdThaIp{L)3H8Z+Bff-r%}L9u=XzTYMys7BqcoMy|7P%9e6w-WUUmd79Ov&l{)sh|{nCev6w)yi6;X<1G z_E&HX+FoATL}$8jnycu%n-LQn3V(LcgskU8i_WfUgD_@ee?z|0?#l+_vN3hmR0`}M zz{tnLl<6bcpEvsNno8`B1ene&e3u@?RzZ-ywC1@aen!fMg{~t9*I7d>Bdo18cnzYE z|Cl0TwX|%N+ep$cfCq9A>eqTH8)`k9NT%4WsyhBrNu zai5pxzX5;qF`asvbFXXFtLI+Jg%MaC1ewa-EMdiM)+pzVsiboCqU@*c(GLyERXTT{ z*J*J<8KZDr>WD}A&if~?HY};NgL=@!aHX;_hbg8%ia9bE9)p=(4RQ|V|2W|w)pc>B zItU|>hkg^Y@7m~3ms`g#S8-edm<0_2gO4T8eH7X+Rj9S)zc z5`S^~6FOed4BH)~4x0clm6H7zx16>>DbRpblZC=z*QTRRh_R7*@D80LY$BT8Kn@b@ zQwctS;bLk~F1Uv87DUWWO`j3LKG&j-d4%7Wa6Y$Mu;L6xEl9X9hFv*(LzQi=yQ=M@hb z`PVwJ7qx}7eU8*D);-9)C8*Wu4r(gAB#0QgDh!YmO(GhnJ6&=_^)^GKX&KYsHq776 z!<6*HL?nG#it4 z0x6kxP-5V`a+kHc-Ce<Ub}SsEX(pNa-cD?le&GoK8XfO^dyCa zBPpL6{1&jz87SU~JWOBEmg)Aaz@UJqUw8u)o3J=LytB8R=NLd|X%5A@xg3#N#isEI z>MY7sHY>b77;}GsFCCmGYJ#925r@oyv`xDR)tIRZJj}R^fXvB4GX3 z^f!TU3!hOh-_1*<5-;v*n)`C`!Z;(CT6g}Ela{*)=5Tc9E>^NLUjdT`YWom!d(0xx;hSt1*E9EWgQ5dV#GYG=CZmZhHnnE9PLr(Q_GY}UMgOf zW9h4Oqe0XLOidG5I(879n-=e0_hyz{y`BJ9GWdiiwJ;|nn79_id_ltoVv8Dv%Dr%c z?e0`Q51E8<*2sW{xq)iT#fE@k7T4VtxE#!I^Hp#9zS+NfsqxWFJ3rn~ZE znjgjbytzsMcp5IjzQOBeknqu8Ga`C7?l?^K05;;WoE7i1RdVs>bB(4gzZ}wNB;h zl@g(wIhuC`Go0bSYtnaLRdW_RW`sYX)NfdxWA-`Wf-q0HJ7?i5VZ&!3j)sG`2KaJ& z12fEUI97N;+o?k@=Oeo@o7^FSv_pMNZ66mR-haOF+a51NZw)KBa8ipm+7n*jJV~N zfyx&QSgnOL;f=jECg(u4rkm9ZIxVIGB%*$CuI~nOVx_oTqK_0u$93 z@g+@5Bv~L>Ws@8wvD7(Ple;ng{h8q^DAvjNEW|YtOYHiFNY6%Yp462DiW$r3#_0XC z|8zVO>NKMM`Sd(s$y`-SyY|v<{&ToZLw#{+$`fqCS@I@(vSIQj5&VUp+ZG{$18wuz zOai24vu?Vk6e{yEhP@FZhKWgsI5JjJ1vZsA%favAD&^594AKARgtR1o9d zi!?WwE0=0G66n#+(|NFE8-a7L8}*Gi)~RE~ zaPr8ml3dyi>4#dEq<40J<)4==-%*#iAbzbnEDoG9^Ci+^hM179?xFHp%k#v6G<4T6 z7%g>qfcRsRo6V`eM%D0e*6#Z!Jv&dtYj<~cb*!=^^@5=RqVu?0tLRd-I-1CV@aZ*2 zxk^;CM2)7D2~%%5_~&oxUL_7$8}nwD$0bYB3Nk67v$+S-&X#KE8FaSqtPP)#sNQa$ zzV~=Eci~bo#&_KV4*{E9Lp+GC+19~PVB3Y4!Xmf?C#@tdNm?W$Y}{x3`Ot1XRLuFa zq#mj&%f54YKK)Z%)Ts$O2QHYCe&D5er&x3`uGk2m|nt|pfJe%cGW z^Wa&S2!WE_z2K_Z9l*)OdUO|V8{_;A!zk&SpFsbw3-Y=A+MfiQsjnDGw06L7$Sjw!q(El9 z2X=kz3%Er5?`-k1t!`dZ%(%QxR9t-h)%qan{E;{Bn*|mhxS`m~lmxz{z@6`D3Rgs& zZZ;D?`b?}YxpB>Kw`^|hGjVg_&}Qi42250w_FRHrcS2#lG`&bfqm*L!Z7TG5(Yx*69Kl1K8_6lX1wVDWer?VLnP@A`>m{d31Qg zB}T`c)f0osa?HRx8Au3k#ArB79OeB2+Y(L|UEA2+gpW+xzRb;D&A=aO>BukI5ik7n z#1Bzy`uGtr*ey}YEvr;E-prcQJIk-&zigI0{Hnr<+=n9CtucRW1xzw0E)$l6da{Kt zta(=)`!^-01)yR9{Al7%t|{3~^XnO>s~RMfwoNM!MKk4YS-%#?Vr#EFlcnl{Uhx%X z>YVFsn0DjRuM=oQ9f@m#wB^flCzH%&Ynw5pifCn~2R?NkwDO)bUbUEHyMSS+b;sPP zm@Ru)0UHP>*z!knqWX9D-&^TC@~G%wubuG_)LN`tUyYIqm6sIgdAK+y4}$^@$FI3( zUa}ILBG1w5P`U*n!*q|nYWb;`4FDW+bAazB$}i$CZ84$n4`HL0=^(gBne-$Ze>S|F zTD?^AxJSP+?V7}C>y_rCFF4sDA2nk(Ua7EP`i{-zatwW~5VyDc@!ey|GUBJFGx`6G zL3%RiA{2i@Q~q_Yiu^V2rL{8dsH2Y-A+aYaRQ1Pd*-N&O`GnQJ;ZL9RyHx-ujdZfk zB)+uIq<(~wNmQFuZMiv!UL`X%@Cz7?&nhR-JIEaP)c2&ozocDxik$}o4N4oJt(~!l zZTf78FU>W0_Wr)~itX@WBW&n_(mjNKy>B$(Tf2AXB@Hp@@S0cok|QcLTFbj5DZ4zZ zqkP;VJd!G@2me6j@hr-!%A+j7+jywm7$wM9w>!?uL;-zr1H90AD$8Gt_JitEf(DI-&rMv1R&mh{ z3*^pM32mWbH^FT@W6%wxJYq8030Aj|%gyS3noGrB+~(d*#s%ne$qlEUTlY)W#YAyo zP*-34F(RFl!0mx=clCoV6-AC%E82`SS*1rPSGTT}Twu#OdU06;OAC2~W@_+NWDFfc zdHGEOyO$cA;#@0I>{cbxi24g(cA;B#$4I<8v-Z)WPB{_0>Mz9yw~E6oUe5lEhgR;#{|Q zMOz7`R|kq-!&<2|5=@Fc7*#&ia)*>eRN4P1__+|n!H)zlUdgbO{G@j-vfP_ z|IgW8Z=n9Bv|Av_ptO+p?_7BQXThHT-wRaRMNI6a$>!;S!!Hauilzf-5c!6nmGsmK zm50#EM)^s1cL{9l3DW*+{Mw}t4du*)u7N|jlo`m?v!9c{62Z8kn;xf{JR%6&E3=9b zuCk0<^s26HTN|cq$ervg+4Vh2QKODEQLA8_obvS$Wp)YzI^|I_iKhG25#@DIF5LFH z_~yzwmRV-hM88KR! z&V=92GWYf9F?QD&Efj~_cbcqBWIE8ZC8|IcYmj(gr^ z^y$re5-&~wwKU1j54?JQ;r66;*I#>WE`Jm7{OrV7c+qtP)PAwrV27kY_Vt)1y_wc- z)E`a5ugJw{pQqWgkc_RES(lIxB$(IiZRM57&gSaPfaSaRWqwnC>#NEKmw^^4C-dTu zz~GFXFdf0kXm(%jdG5eh-{O^xRDSVP>@F`|d{z6aF#(k8(byQj$5*W$i|lgzjeRLT z_o`~i?)M=|*=nMXec(y9Qe{O5rfrp7vk@ws_`IG*?<2)vS)`A^cT|ndBX)wviV03r zQSP`5h(nv=4u z-)-q^S{29>qmM{fOnB~!^M4W zfg8xjg0D^Cj~)!IrO;41Hm?aCa{f~cBf*T+D+#9lE01;<(1N6>*_?Zv+1xa_IS}V! zuWbVVqQ~G8h&`rRvvj>W=;RUfdPkPW%l7;s0lFs zexNqN^`gDm0lTmpg0JbWCw}hl#>jVEz&?9F$mfuoeS3fp9p2xZ6qW2_#CU>d84P5h z5--U9-K$+80Z0IhC}-f~;+3}?J-;w6*Z^IImsJZ}PLn+c~_IKlhtUj~#36#G1Jv zeAWsjLYx!ejK)z)qy{_j739naWF(fK&Axt-h=EyY%R$aYDRfUpt5;L`>r64*3B}MU zh$iOGqR+^|I{$x!6#_=uWs8xD!p#sw97xkU9@=_HtmWocY%5%EjrcN{W5xFM!29`( zJ%x;1x(RD6{~;Fc01g>AC-rmi=|ap3tZAvDb`x9e${Hr-X!2f(QC#yp%uCevqPxB z%_Qr2aq`I8*K%lb2M<8AjDa!AF4a`+JsXY88FXOw@ZeLcT@P%vG~JzSFGS& zSc;~)0;9qH_P0oud(SGu$`BdRRFe_Jk>C0LBe(mSDC15>OFQ-B(E1*@0?6}oB@`E+ zPvK3HK0+Q<3%NX>q-~!jsLAHyzYJrQGz~*e91r?-gU9fdYUo2-&er6)Qqh-8 z(BLp-qrxsgKXTOo6}6(0RGQjty69I&n)1V~g5UQb2gQ~LB{K#mH})tAEmL3lZrr;3 z#d_t*`kpp~9$66qJtzJClS-E#hvY?%zPNshcvwEy${?e`@4Xm+=d|G~*)du(`wkW4 zl}~R1#EB%_%KanuSj`i9LxxzMSA0+PZv6($Y~Z4&kmpZjoJw`nx7E|rtN+#dIrMot z51-v$;~`s6y?|>hU!0$`tBf+PU2FBm&|cownP$QE!|U{yOJ$Ych;(P?_yBMyqK#e2 z{rOg9;&WeRfpU$CcY9#&_iB97Ytgb}&u@BS{s)rEL)8H*1>~Jv(S0I!=@eTu{)V&j zWd9F6ywt4Z3^7+CZD05u%sZ9qjl9AV=AtfUa`yz@S?aztE1DTKD;6xCEkBt$iAX=@ zaQKjvSI$!Z^k9}|nPpCALp+pL;8rs?pBe@0z|y9}-Ouai;xQ@N*bQFGo2G5td%OF} z9I9lhM89f3nZQ5sV!a#~vY9G0H=KOrXd$&d_f_HX;*^e``=L3!d%I$e$f(w0EO5GJ zty*4puCcm2?WyWp{!5O233^gcUHyTAeRO<6&Z2xTm|4*d9j;bP+Nr;LF0iiH#}1>*zHb4VW!vxOp%=;au9gCjGCc|X`dpN@SC z9H`@+z_xu8k0eACaJJAU&KnfPEf4rD@fL^vtMvjY{f2@ zYhFME!kW>yF7&0(&-2WHk9}s3rXIX!s(oJNoz`BCP3EtjNCU6djj`lYBd~cM$4M@G z@z&u3VYfLlbJjKWdo8f&LKm6bTWH+K{eaZ&p%cFiYH6VO&TUg#E_V40epoNDfO7Tv zJs56J&Pm=6b0*vD>ev>(ZCjpfF^jm=QSfrtr%wLcrw+_XbhhRH!qWe$)IhI>USWqM zAD>l|@|e<0QTSQqe936~!k}fq&teg2B8zT{b(T&eTX}HFKfPe{jm*MjR!m1F5y8AQ z5f=w*k1#lHbLiU52*LgQkAP#SR_;+l<{>kBxv-Le(jVH5X1Ui1kNf^29LnmJ7*j;1hF@Fze4R){+1XviJ?@I_!dYT728z2rUhTau-tH?S)_irK}J8D$x8XdzA| zJQ?x@+6oo&6Ypxt#cw|$ej)Er;#17yTlv(X8R4(aasDuQt~uZt%sw$kq#k_KWyZ>l z2RD0;y|h2q0ZVQ(eDf5|H2^a#xU$HuX`li3JKc5(moZ#re-_7UUFvrWb%w} ztN8?n4Ff*oUJv?!ub!uq%uO&;A7qj2VN)gI=nLWxvUmsMr7D;?~2LWc(`8)QW6*KE9Sv*5M*SFwHlO6iAqY!g%UL;@^Y zTV{hVl8+U?K#vu)^h_3X7PLqWcKZy?mgAx{Mq0H6`?d}liJ1F-`n$(#q(ztQ*89NJ zWZA&Mhpjo`YfWN@+)y6SQS68mQ#%_aa(7#`_d2L+UqYQhTZ*{6h;M>^#EIeL<%qk2 zvI^f56eiM24v1TW+7qx|nPS56l>P*Hg&BSAnRUc>2#nq0vN6M}7*6=S=Va?buCrg^ zZA-iEo?lwe7%Va|$!7E12u?JS^xEo2gKBspPnLMj!^`4N_Rf}P6+h)|;dPh0xzEzG ze!lqufpPzkS+8u~wAH1_NezpwXLtMxto7Ls9(lbBn-qmWGX?gE9Pe%lm2?xhdsa3| z30%FOhyJ54V51_pNlmsc^1Sfkv)>~B`Qs~P4&U-I;%iXRX~Ht0itPv6R4pu;;J|Lw z;zVvOrX~-l^l((l^)xXS{4aOs5k!r|=o9gX4GFnJ{*RseB&i6T2sHBbVY{w0d-o#f zE#;|KvGlg1Lh!>TCA5#q=Z@dM#0cb_Fv+Q9%OUnwk$Fqx=dXPAw2@A}UTC;pl|Kr> z9g(E_>JB+fxGKjC+rH->U)7u>cyY>ZT09nK?76G|A~Z&h7qtP_J3v>yQQuPDLR5%U zjP9~Mf9|9!7n9ehKxLOv%;V2p9_yHFjM?8hku-Qx-9*nq{zs+5sA;f$tlpvD;U})Z zza?I;fB(eU{``B?Q~G=hl2g#V6w|A_-742<7Hu-3TarozCaGmFj@y)P>u-p{Z&lz# z4CMCxN0Pz&nsV<69anD#@p?trUDlH4t9;$4***M`z%U0EFjjEBt4RmMt-PnMI7@@*%+*d3LdpocGn;@rHqD-Gfcy%Spq`v5 zg?5)2*7JYbe}Mam=LnsKMs^8My>DTRmlAtd!Ijcl#ub5ZC4BtKA(+eecbKU|gGx2JD!|JsswmhRr>3E4GN>p*2wc&t)pQ?e|>M{;D4=2t=*XGkQe`R@y|1X z1OIi%`q`86rLyQSZ{@)@?$wC|7j)GdKvt}Ev-FFz&-nV@sUu?zIKSo-TK2N zN7WXl`(mfSdf7V!YHdKL+2+EO>w%CvCm$d1wH{`IFtk&se=(A+X0geW-hVxJ8*4`f zZIfXgc-`K!igMd>e}aXx_EV&c6JUXQt+{a+1n8eH9?;;dRBN=ZAn12^F;ho&Q11qU z9rF^m&(uT+Ek28nEDuwhj~z7kh#C)sUnY@1bb{nw z3k47T)^pN%JA1_I<~~o=Yero0MqIT{4bmH*5j$jMSh3%;;56#~3?;T0eDe5_13>2f ztA;O*@J!3{RVF9!v#dy_TI0_ml!DoIsJfN$jR4dHR1au)9BZfDyF%FHaV#4~PE(Q# zO$y?b|Nh1P^!e$8i8R%?^X+nKuu8k?kOPXeKQ~DGb&(&a6HAGjZ;U*8Nv37}U5U&N z(&ZDeehZ^Fm0ZYb*WFYmgC4I8oVm+QEv!a*@v##kt?m1!;nxO(?;$qmoA2O{`L14z zL4IKTt>Ac8QGUhA=bnYjl7G+U|3ZfL|50sksg7M~-L=fW`BS3PKgP_$D>!dY&{v_V zeL>2{?i|J6(Z4)hx<0Fi8Ty$>bc@Zs%&4AJapH79pN(D#J*hPFFaAB={r_rFnP&)g zB)Qfz2A6*dK9*)iy)ygeoqjlhbRW}u_THUP&VG5(v;1ut)-ya~2hOmrs987vX*?2i z-omBknk^--_VFZdN)jhVXZw`ISrc8`Z|Ckghja>?B6`lMAz&36_Pv!9o0X+)GncW@ zE7{NdwD!^q+w^v({TJP?U0?BF?2!*hs24u5EB#JEBydbaL;n1pS(o<73&z{|)!Wxs zwmuZbWfp!~NH8_wKc9}9<+g?G?zJ?&j3G>h?B%8CfmHV9K=`7CY005?Sv^LkB|0yE z)Ea*At+(twl62=l@Pkd`z47>%_EWF#9&Ussyv_VzECEa5s_f}DZJ!5udFbvuJ&?Z-6XM(Q{ zSj_AMeiZDb;~L9C(A~(zVo$~ygiIUk(qxOetzlw?$@W^%GKqJOK2&RbYn=6c2Xp@R^(b5BWqbcc zB4@Dc?lbrQ2Wjse)l~PbjV1;RpcoJZ6d@o|6{*rmXiAeJSm+?V7XhV*rl3@%Neu`H z3QBL%MLHO&fC8a~jzEAw2ubdK-`{ucx%azc+;PVE{&dUUBWt#`)|}6LW^lvF&H;G5 z=i3&tK7it|JeVQ*rr&uS1Nr*RCGGly!t3fa2jGu_*M|ezB^=ngpu=WAPq!U%pke2H z-!Ivd$({F3@A-UGx16(^$1IeD#GkugDJ%!&%-Vn(oQ&9~J?uZi)->VY+?2;b-{x@*g5!wcz{alsl~sjJ|gVMTzldG`lP z4Qox@KDe3n2EzI|(9&#~;rfIu4x87#NJcm+$RJ*}AEpO{@%GJxKfE8jt~?p>ZP}Kq z9bZ0Qo407=5sc^D!amXO*5S~mBQ8STDPfm(sFrS20|Hex(E9!gSO{~~wajB>m`#N! zAjGsn7dBcyJ&s;e1gYmyPC7^biwmHapuYkhcWAI65|V`8%G6T}668m_;fkU^UMf;p zo90={{@md@vz3l8K~oJvc*h+5XZwrNVV;dR=M+bxYET06ouls(3t$+o)nl~}~pxGP6P`y|q z5vlr61~3JK^vZ0k$E70j&=i>>Pct=2s3)4f+jxpH5zF zIWq_`rfj$tl0kIEOowbKY-vu4{U}udv`4y7Fxj1}9l^Z~wd*$rb*-19*|=B;(J2VD z$7F&2m#17wje*2`#OoVI&j+yX>9d1%XaLC?em4WMhxTh3Ij?dzMi37~lax`F;d`m? zuUSo#EWNd4`N$yU+6Sg<@>Ah?wAxECJT#Bai#!6w%3YtA^{s%YoKNXy zR-^mOZu%L->Z9K7y=D!KU>A(%eZ}-pyyhYJ)=Es+l2-+N0^gNeobwxbUPRmzrpVS+ z8~ChA?giOY)Jle4eF>1iSP>zt36r6%7T%@ zI03i!R%tsbUrh8S8bE2dY!>2?w3h*Y}_Gv2UY0M zpXO2WA}>@u1kIO}iM+C72wxiRxIiOraJBd~G-T6v+J4{e$n1bTg|AXPV?6j4+>;;4 zNoSKMmB6lQ&@~MF#P_^s64amyOh1&JuZc(Hy~!_Puol;#xfXrlId@F>sH_d0%4Id3 z%k4G^bg~yXx0IP6MczM{B7|S135RuEWA^$-L)>ToHw``XZ`$5J3VkZ-%QT3v&RdX? zpDg0NL4Ar*>VpP1EqLB0G^OS1%1oh~PG4|~sF_hR9C5`GM_AFL00T=3I(>{8XeO^X z#Sh3R>|6^0;hiRK@sI8=pXvE{J?A@3|10qH&97}}b9OM@7lemx1b#|@Eed{obFXnV zJBy#K#i6`~aO1|PP$4z=)~eYY{&6+xXeNuCSxnw_$jV@RB|_ji@Ra=wv;I0ME5D*m zyh}9H&NE-9+3C+r9Ng>+89C4_T8`X+ygQw)-g#zj!W8vjt-boE{MbPal>)s%$Y|HU ztqlhW_v&X@fEfOj3MNCcm^cqb2p&OBZmP}IPdfzW|_e~PhXKorbAE5i;WJh*3~XTMis-_TIT%3dvG)L z?49*td}?Xyxafd(@CHP=Z~9pBtOdgQ<>kjt&!6ps26)4|)Fr6Rn-)aDZ`kR+d+Ja_ z24b(`F*4+4xDPOEoi!Z|aPt-O@aXd+WQHJ92_>+3sSi4Zr|wntqn|XAP(ZWe$HDoc zh3NIHA4MXn!IlK{x-ZwfzdTdXKmO~y#`b=hW9Y6>Eke7g%oX-x_RgON^0^o6BC6di zWrw#!w|Oou+ZqMMAA$4m_+({)bd`@ZcV1q&AN6X~9}1=uYW~aCRzd1Gp?2<2m5rCZ zqh2jZ6&kH68~jh~@&81u`H}QeaOG__0&w$ie^o~Ng_O%*PFuSQo_F#=^{0~**&vs$ z$-h_L+`mBuWs-PPeZ)onJhB{om7~^+8x3gB7@9qrVSLtCz)V$ea#hK;O8m*M#gwLM zcCIRZC8E9hz8IJEBBk61y1e%zvWC_7>qN(|2xV;^4CL6|@e3A|6VroeXTI?qK3Db! zdcKDuxl_S9?%;Xxk$F}-22wF{UUd`SKm$sf?+ScXCj8E~n5 z6?SC7S-3S|CFgGm(fr5Rn}s3?Xk-Bm5CopNRdk%q*(_(O@#dAE}Jf$%$g5OLd%71mP!8!@ptca4*82e~5nkNybbSY{lQB=J zNMN^Fei-_e>BKToKu3Nr@vmnw`T zKQ{u!4zK3feA~t=t1!o&v##uI@A@Vbc6UvJsX?~)h+~MtF=T2q&heCb(x!cN@@J7} z#m|6Um7Wg@NS0j(PI=sNUvfd1FIzyTO}WyMOLqe2%~#rSkDe+L>0+|hvoO!z$|ehf z^l$%qESFNg*`#=Xg)MfmlC4`LC2VXhkk7XoRx*m0 zUMV4`8I*SaU;@L>sfH+k@XGL|&nQ0whSH@6vTZM~eSSBFaEt`D67o&uyMv4728OU2Sx@1Ack-BG_=fNin@}>0L}QvR}~1fc1^BIVjdXoOWCn zT=pv6GVl{XGjSY_uKHElM0v+=(oxK`@nQB-`*q(dbmrH#U@qguuY?-)U23Tx(Rn=o zzN|9KbAYfusd2u|NM!nU9`jRQp%G|JF%#F;rt+O z3k?4vf(WbPDL!*GIXXTjVPJ}UsWfORhV8w)UdirNWpZ)w9ydqaV)8i)Jn=?+xOf>F zyl1bk0B=74>Nj@@;F^qV*QYb;&5Boq4~P3y$2ESn)weyj5=3L!l|w#6UF0z8{NpCo zIRES{!yB(`>Xb$Yb+_BSE!NrFIcPZW{#;HE4dPK-&g+i0lQ0kBcm1mF)1;+Nk2flT zu9S%te9F3PFd9S10X zY*$ovKA?Mu&eUNfVGb2yq>CST5;)S-K(Ql=VZk5_L=yva`<+|??ky46XJ^p_Mec#z zsQResR(yzLh*M)x!us*EDXWE>z7UVCuZlcK9cwz{D7niTj*=L@wfGgl@_(3USW>c~ zt9JYs&L|mFDp_-djUU{ToXnym6!Pk-g$h`)sJb{T=6Nt!Gk-fzb3&qC42gU!)A5i> zC2v~YthC$yxzp(PuQSEqA+&dI-45%z4q@B;2x842P|hny<>ke60VgxNd7J;()#p>@ z$u?9$!0(#%vV}sgsLnBD{W(t**Vfpol1$p}7f;m9X#@e>#B%l-vvig7kgEy>7dc9C zS3!q1tgo1*wAc+1uk`hN{NBA7zoOZJuzr(@)A$?3V4rEsM%js7gfwHhzg-}<73j0~ zni^z671eAtMX3yX;C{z306R9CPW!POsDKTr?L!P1mjsT(wLj|1=gPQ+(7%tk6 z?|S{UGYtVeM6}#N2njC{m_CfMEKz4GmU(SLS+`%9^Lo}mhzis@@B7@Lel#CE zM|we@&P%i+-rJ|^eWE3J`MU?PY+LyO&M_p$CgS;ri$-NxXN;r7Z~mn&7NP*tcQXp& z5h&0af+k{S6l?{kLm)Nfr@ciE+2r%{!ROr&Xoe12;Hg?G6a8zl|XrLrxuyRw> zEr@ZHJF%ISh6p4M-#2P*(!M_>snLo`{aN3p7NFT9MI8;A9GaEP}HGCD!B(7d%4LrT^Hzxdb%rw4!Omhr_oCx<{ed4)RdzP-B=Hv~~YietNeld^fQ`s&}?jz8ia;BpXT z=LO7R%NmL8_5IT=tz?1ok1<68mgJYGw}8Qtr(vmkj!06*yDQBdgQh>l|f`)K_&ICumf%3feTzeRu%%N^kuA9oMwrBlprT^=T^d zTgZXsXe(`a*r}{^>iTh$qD4AtijHuNNUB8zPi7DU+rX4w%w7(nC7IZ?V|6J6bqCXToWLEw(p$_Gvu43+$}*Kbf?#Y;ACBd_0i$? z#n!XWV%eFD{q8Eur3Cjuzei~O-x5g0xI6DSsYzBIDz~O}|%nu0E!^ zA{%r6JQbo|`JGMfD?^vS@&ei$__|-;>Rqlcbtuw55@TC-YzX;GYr9m$arRsIroPbC z&*VRl;)gptiKa#0w`#`p9NJn@BS(>5JCI|V^Q{JpQn(~xsfd2)^o$f;&x@)=r z#ysyk@~jpS|M(tyNwFE$TbvyRoESd@Sjuw4_QZZqVgbGO^1caB?vT)|iUHI5DKKb@ zA`SQ=Ui&r+pN=M?vJ-#Y4ehgKhMXz=N+-C=*M=3jOA$s(S@(EOW7{w^Sy?%vi? zi*4>pdL)fJJaSc$K63n`nsG(U0v*7b!gIE9krx!@20c|sn36_e$p^xN#VN<1%OD^ zJ{Tf@6%DDU3~{U??;h>sPuVvjfb&1x&wm2Q9+Y&*sABR9?pa+KJY4~L+VOg%1KRtE zH6+HuGKUQx(b78fxWC77+?c|=1v#lW57_7Y4ToWAv6!P*94+5`~CYnLCwZIE^-^Nd&QJ}BvyCSV0lP1gZ4 zZ+tD1yM&r~L9Jl6ls6tG?U0&@AhFn%Gm9L9jMmkPX~xv~TF~GNgMC zQj((Y{sCctLA0w^rCc%@03srKc>UXWZYlX~00?)87lF|j#2oV0%^IImtr|A7OZpWt z6RHfPt7N+U5R%-*`OoIQQjWlQurc-IN;$2cIsdz{TQfb*mu7-YVZa#3A{vwbtI99bxN@RrG)^9W}JWb;DN%th)Sbc6H zFHvqqYC4EcH~%whMik=W@E*P}aATbe)V@5Q0l#z$|~rX+-( z^f?ND38xMnvfbVvZd2+|_xn|BoSMG(98c|U@e3!+^YIEq3rdP!T_00E2>E%SdsZl& z^)|9Y9iNya@V=dIBL2gC>b||^C-Tnj26bvFF=Nhz`ozNTkQqA2)gCh3NS9c(sEJ(a}AH3gmOu zm*T1y)HL<(-!`V;()a$jS@>o;uG~Kk3twSbh8){$6t9!4me%?nuXN~t!)JMJ>kvcb zbq)N%D~qwy&^5kK2a+klxOvp0R$N9j*-^{b+J;Dccn;T@DsHK+;B0t;5SWOCU)+Cp z*<&D`pxm5+Isj*ON?#FFLc5HJSlvlRMe`z!(wVfk_9BOj4(`1{b#^Cs9@x=y0Y_-w z=JlRUxHDa8@UN&z)h4palWl|jyTRS`>PSy@@;~ip(yb%)(>5Y^(l#@VBrhDIYb-;@ zHa1F^6qP@b%QvXK1qotABZbxhL<(RaO9Ab1vM^)!+7(>7)z7Z`!=`n8V%7lJ)##KG zFDV)$P(gl;P#)mS5WbK#=GL~oPyg1y=6=X}k>muB{I$)}-%t$0?F(rH-kJ|<);%Pp z0jc6HXhr;ufL-uAZRF#01pd*|@x(Cxd?!WHY!9pzDl1*9)*6x(zassctA^|3kBHUE z%hxChLg1Nij?3GPF&=Dbht64<3#;{%41orzA^#)BY1glf{K>LTQn+)TCzao18$tiB zKBD`+W2YN+Sit|vq)Y{+9(#df=s^0P()Bm_i%N`$0p~D5B2_+U_i&e zP!z5uWuwq^3z|aGN3qbUULX{)IPNFr7nHuJ%!^ zJKM3Ynnw-6pYH;v1YZVcXJ{XES23(#S;8ME{|2jGK>LPQ`T4b0)c5# z;V8^M{AY9$M%HU-7(b{%LX$SklQFI;-xEXQ(pk!i#nw;$l$kuy>2F>J03nSYr!t4{ zZOvb&R#NXtmeVrw!S6oEpgcLWw%0pkn_H*oT%o%cbg%b_4!6mWaT^t=rZdlXb4CP? zi|2Xf@Ai)YJZ95Rvo0dEJwmv4`bxvMtsZ^;W@r3Q%+O{EO$CBR>p|OW-Jb_pkDH`g zaFCjrd{t9d6)jKQf5cnd0c2Z7E5D%2^Ot#-<1OqsqgUeIVIf=0W< z4+5(2c=V`Zwv{4>Dq{5!AP8^r24=~B3Pq_|FBKu@vA&kM`(o;WmF5!R$UF39NA)Uu|8wN?bo4{dZQq5Vtgv; z_3g+4Nindv|5z_Jm-W5%eWJUx(K%=9(8D$Wt5n!ArR)PVH!HM2d}mmW!*!*_iO7cK zceL-Q!)mbpEO)o}jXqef&Uhv#9#1KstCNos2CF~Z2#XMc!rkl_Xg@BDBjKqdp~)Rl z0`vM9B=%Oz!RYnK0sLA)qG7+a4|5CnWl+2Rx5bTjR16g_dM{`#KbqgL^n4Y8o--$$ zJ|=v5=iN@?;6T>-?pwXHLD-P8G6D49cE`vSc3Mw7*c}!;)6>P4yrlkBopsKsPT+l9 z#_$o<+xIL#_u22?C#i8`>k3s5`CIipQKUbyckkQ&vZ{GDxSqzxAT9MEkZ9?bLC=jo z*YI_C z|Nbtz(onp6L55p?>yX2s>D?(ubjugZ;_TCjY!8zU)(PH0!%Mk=c>=KtUp5b| zT&#||(EFby&4nI{Ua>lbQ}g`_No^U|{EQ8`Jyd5!Vk0>3Vo5L$xr0WDIz~Bp2n!RW zPk!d4slVp#**JPX;KLdZHg_H^U1ss^f6K$dSz91!09KfYIFXujFdHVdVdj=0{$=VY z0TN=5HRsrJRvgJ_mA(=`s67r;Rff zX+Qh$k4@OYwJA5tt&^WB&v9*~6&pLl3fX?e|AefFV9~$5_h7fZagTBXxWtB!bYDHs zC>u?%Dr+cUH>AEjvfk$o5oXxe=c4)|-Ig0TWF_#n0ViGe*J38y&_80z@w)JjZzh4v zq^Hz?X_9DW>ZHqj*z*sAkSXXf0v)gCNCI$n$hUV=$ll-S2l4Qg0Oj8$IEsHKV<=ai z?}D#F^H7>`*jR@%S39m})$7B3_?UUKTs*O-+47-3&lg&8r8Z{5`!d=)&qg^1?5O+B z^5huNg@g#X$_&XF|7o21FJ$uRa;!3aLhRdvV^ zY}AzL*t-Owj3YtylyswXOI#%?7xU%`#Z`@rrRT4V4Y&09r+52*b8Mih>Ua|0TARzqBzf$Ri`;>&1GmVXUS>KaM%#otnX zY{E~%bUf;0Vkb~YoUFtc{jvMHd*KQra#PBr$~ANM}ZPp8<^m4yh~!u00c@Pawtv7sn7*umFke2;L? z$VuPbwjKQ1p9y*6Y;m7gUN3H$DrSVSz4!I%i|ijLQ_r#ITLz=4%~yGZSFaqz0}it7 zz%CIw`bad@yuU4@Rp~}e3hIi4lRko2n3O(#@hBtX%_0}>Y3e%a&cvA5R^nji5vS}E zt)abhtt6$=N%?WEW5(on@YOEAP51iWO3U(;6`3~Y5ok{Y?|zI*`e{5e74YrB#h5f%ndP=|kfNN#h-}!Sf^AxZ7t9Rd$(~=NP(VV3;F8_J- z@xLDlTS?{p-jlyL#hX2U zldMRpIzGckB;JS%wzCuv;kiO3iY5VYf?YWLa##8>NSJNuc2Rxq1AoyAiU5hG!$8}h z#8OsqZm@8wq*3JK_e;@98P~sa_vIVbtfZF`3m8&Nd5 zu2%mbD2!sl21CXXlKOQr@ce3_1ttOZ31@I64EYTj0kUZkwwW8wGz7X2f$K$VI0dZ+ zG@FHge#OQI`!qmCd`8D35A}H~G-OZyTSosgv2hVJ97|!t|Gs_j76xx8`{($Xql=pn z3iE%&0Ic|;%;@T!%Tl+rtrORhFxVfeR;PQZ#A6$tqGtR(pLdY~VYa;7B+%}Aaodl4 zFg`ep!#iiYVY{mA5_Dr<5yovwQHV{5!?|(cy-<(wuXXfE+5T zpvFr!$$dfC&2Z`j@H@OzY2eBlsp;dntlQz6bp-j%_b|<}W`po)sIts8m!Oy;7Q>|q)c>R92hQ4R>3Ao~x37R9Qm`=CRJZ@GX;LxU6px3NtIDlpwt9f!n7;I` z)=l~--)V^36-I-8))qBukr>>jse#@lK@C4H>+SGh;)!_|YI{xkN4@WU6>lXu=7$`2Cj51+@6}@E|T8MMQHn{KfDFvoy-vp&Z z`|yDO<7mp-Pqk*XbTrYkoq#+5$EMr*MnIM{xpGEr4 zs-dBKxB7&f+Exh=e~~r5dO!$_>~0=i%}M05@r+z6wH*-x7zj5thWEmYM*3S$Y&8^s z6|FR0H$jOYo4f$Nd}r!(t!kib=)ST2qfF@Fke&K+?DE2W8oF!DJHLbsbzEMjpAr1~ zfa@&!+JAzLg!f_=3lOL?gsyKH^BD-49dIp3OyBcC`(E#g{iP1R9`(xW8m&}>gvzmy z#OROr7{W^0j!dR_W3S6jajnN`HAYDXYh%)#+bwsvX(e+vUG7-3ATjiy;FHk>siv(e zpG^w#Fy*SQt&Q?>cPv-w7lPjA{K+M)LKD|7FCKim>I>X^p0rY}mb%VlYz?3d0@}-B(xFW_K{ z39bTFFkDk##+d-1j43)YpWEijTyBm^b~RzFxJ960S?}|d;t03JZ&hQ8JoiiHLV|V= zZoN!Yz}lR1foV~j{#M<5`UfxGXf02?t?!V+y{uBQ#=f7iVnH?Y=*uDnqj#G3FJSV* zc<2|t4~WtjNZ}LKHPwu9)n`9QH+QduP?c)GlN;@|-tu=V_DotL0MIeVkL1|0ve2Tx z(VkZc;DHetdA~)a;q1WACt+W&HBar1Bzio39*~~%LTG%ThfWEXnmR8ngK&O&M_xD) zhabz6nb}41z*pOsBcLCjeST@64#2zaSc-it&{^M!ll)1i`0Pgiq^;3JH?G*2H$Krq z4WWEE<|;kszqImJW8FBkG6=|8iHhid`+N(1Q)iXqpih6#PTgK_E+-h&@|1P|M{`VN zPRQ-!Fk{pLcyWfQ*(<}mU60gvH$9jjGjO}f{PT|T{$V-#s=v3z!&ZysrId$hFw}A9Pqv* zx-C{qf@2`Nvz3yVEj)NWt&5Z#f6%b4$zrS9xes)b`E%{Y^xq(hwv7AB5kFWdg=1He z(S}?pjzF2R58Axw%fffUj(Qx?vl3XliJsW>!F{U=wzU3Ej`x({hN%YLRQ{(hJ#H03 zez*hq5S&{OoU#HQrhaYuC?3wHk3XDxh-1Urg_%c{*jvwEf6#iv;1?1gEvC80C1>;l z>pvDh)WDZsLka*UL)PKDuVt_d3`?ERGOMcj2fm8WyYJ-;SWs{sa9L7oGq?ym4H0*v zv5(M+l@ed6ZV5dQMR3R4AIGmy4!5j0mW6sk-b0TwZw@XY1|hyG(<@*-jJ^_X6->tM zKgbQXlU{-Ef)UZk>9zXxH8&xd7{SxulN1yG3Q;+=UlGB5Dr??#KaBFz+~dh@M~^P=rEf$1{pe?`vMi|p6fP^IeHibDwEi&lfB=yhR?Hg=ujSU8tmXaydcdGh z{4L~s`vHI`t|(#;+>7IqzMj<;Ozyi!es+4gimZP22Ijx@;0mdVlK!zi$I3r{0IKfs z50`R$&vIW=-<0B$djsq~f(et@DSg+gXuLE-K{vCiG6 zo10b0@mXqvo0(hX%XMTT{d+O9BU+UYz;|nMG;l zpED#^!I<`WB$=qs2!|z*c8(NmoNt{2@2Bm2y8IU-vdIsG-qi;G-r{%%tGf{*E@9<< zdi-vMVX7AcGz&G~>@T7%K}-^9*0EQU)@;A3Z;!I-6LD_?EN^l-biMSyqO~W9IhBzN zYz7TzRBoKn92FcPFC3wqp3l0oZ8qDk|4FId$rkxWa3iua%+WN)&0Pv5OgqZss`up% zm`u0$I)6qUTz+Dn(TeHw)D2I5bz;Hg2U;R%kr?hJOF>!`~=p%wJOLWY2`t6 z%;`deZC4T;b1SB<``h57krc#100ptPHC^qq_bx`r=mI~y!ouf@l2C8f)bqygin_2H zoX>W7>NKlIwQml5EE;wAJ`ZsU|Fp?~nBS3xwchmkkbPU?B|n>~Rp1n`WwV$uaob6C z99RXn|Dbm;(uOCo`!m0r^!c{xfd{W=B`JDgGeba}n`0QtV1SpN&x!Lg?H6*KK+FBLVFdt-IK0AU{Jwo6&rCL9~;aLUUPbE>dY75KSH1Ki&MY$ z*y5{d#Cs8VDnn2$aRuerTFSJJAAOMn^m#fb&*R~hFwh-UegWCL0R_*mV<1!dqgLs# zT{$`17^7vbOz7^5@JcUWswt|uQE3QrKWX4_{#qt9`}wz%u+6W2I80vp!h&Hd8roa= z>2-q@3Au@7fHSSU6h?=%-}d0DP`}FJh_P*y?Wep~3Umi_`D){ax%xHVkO)r*0SKX`)bz@a zAFjN*dKAEX+H!x6hRA%VVR7-I4N=g5;&xNvlE*4`ex2?*m72=26pv; z&8}`0yeCz6n`o6%@Yt_F7CO3F{C&GW_LknI3dx2vcMZi_X_w(B+)heW!=iy!r zYt#(gBTBX$>@$qcRmJpr(b}t~Wgnu+Z4zA3Yh$PFSwFrL;B&&jYH+nGMU;?LQzi`L zHyKDurJ;T-XwXIGFQ=b8dA%o-{2~2%B%N-fTwYhNDj~WT1!#Y`35MIN(g}+d`$Hg8z6NXa_oFnv_1u zc;t#Ytzce(H;*WmQ&4GJFkrz~SQIzwKz&F`z+Ak$Nh{>61WQ{ajjRv;XS8=C$}wV7Ux#KnBH8|Aga_ z&(uwe)|QcLkJe%>1cytN1SJJhoPOLnXp_@Vg^7I9%kwj_ey4I2rXYQ1UBp4$KF#Te z+;YJg!qk$agIl8y-a4?2jF=22mWawUZP%Gq-{4>A<3^L^IJpcx%}|MvTI-P?xu z_>S6UxGdcX$Aes-TECS@KVAH>;xo>b@QzU78pxr%*^y-wJf3UL`Om4G=%2-CXDQ+J z$?1~%{jYwnB-|qe&mn7e>*~J<;v6~A0FZ#TcrZX}xxRn=vsP-Ng4rSFOP6a$J(rV~ zcjE+18rZV7Q49O@;<4g4M`B!M1rhU-K|c^k@9#9#v%mz@j1$E_?$}jPG0IscHKlhC z*ZsLkGRu&u=ewQo?7Gei3d2YK-P6{|q!LaayEt~iR*W;pkO|BEE|^pY^0n@)mztd1 z0w6gl_-^SYs;lrh=Q08fpwCZ;G;2R%7)rfo_Ih5PsIg5BpDng<=YL02a{{ukTdbMH{!Hql1*yao4+BZlbP2fObt<`S zC%tYU^spTQbE9CflrNH0@JYbcR(;5HivM+Dnju&~2Teq+(WChsx!P@eQvilT}P0;V%16SMcL!dTynee_);*rkb*z zQ7&q@bw@4NbpCzUI~}RTt0z_is-Tif=|#eJ#iql@19NsUCUGXO@0qKSb8arRPOS=z zHt2Wn*fqVF1(+`LF|cKC_zk{pf3x=_UQd_MT~CBlYg7*w05PalFE><<3XC{9Ht?<* z*j{Lwvr{JW5UylGD_|f|OU0GwtNPlA`5(!8ZvI?hvHSbMQQKEn7i2PZaxG4fe;bx2 z5(mPVZYUk0YqBRwQz+NM#miK<(Xxnc7mFX&<)wK_DlUhv+ zJ276Py<+J4ZWRn6w10X>!e*~OGEMqjz|L}CbN@SUTkxf!a{^;Zh2r6Bsv#hF%amVb z)G6ao_{#19J*TM2Q?!E3voDg%pU7u^UDSzlN7SrGXOhQe_IEpB>Cwv+o0o0eIU7?^ zhd(vg=AP~Ae&^S=efYx;kSm@fwyqvo4T#!@CUvoD{CvQMp2}rI{9<81KpUB^N{xGHs5)y!J0n3}q z7OJ-;{Ohcr63nl%mb)~>10@eLAO?FjFW)96(2hi0S3_7>CtafFJF%&s-m^scKJR7o z0nCtL`PyrfTaEvUq4t)DgNe&OCTwkf1BkCJcJt4E#q=3UrZ}@)sy2T1kM&VqP3S=X z5vxnMEvwG$|A+afW%B5Ycn#Y0@m=+1B$wOsfF8aXFqHfu^rsjo$x#Q;55^Ra%$Y_5cFJH)>jTc)RYUi^B24*srli5ML3^^(p9X z=03fLNbe4`B1*_;R0sNl^vqPP_el!67BO}0kLfu>lD|lf|A^mRz0UxDiQVJ(P_J3Q zoNM#cMoot^T>-8tWgpHVh;}G{wSI&K(Dc-5as-i@7!yQx?KX>*Gk&%tn+|&bjhOqO zMJS5eveR9wg5f}mSepi|htULH6@~llpLmY(3#ae0haiIvC-y%znon{%Z@-;HQ-Fqz zNGhj}&xjROU-3cZt&!7yjYc`&u8aRTGM3WFDnqOqiL)S>%l&%%IPpn*yJo~y6|+SX z9C-C|)W=4F)}>+HHUspJ#+|u?8yEap57Ftt$i{hkH0#vmQb=${ zu1#*>ptx^g)SS#Uk%djn?wgwYpeqWiJR3U#Y|rd0^R}7v1Rq{LVH4(FeL%hWwc-2k zq4(i@%g#4bzelWlrr=8BZrtcyq$AU2rnj9pc`(UrS57zm-~>k{>kYZ&oRVK z?fmk!kb{w5)GE%O%{1v-{br;`{@h;O39f9+ViVqyv zUW%At_M4$Pa(TM`z|OsM(T-)+&-*#zH-~KmKm|c;iSMR4{iWS1=);3WyLj6LCi9Hd z=V#A8I^T;pTrGb4$kXCvaC^rVPB!lJOg-eGUS&S{JH?OxHbaHU9m*1OqgL$QJF}u_q zD5v~>b1I#+(LEsJ&WtDg@#ShiT|fzpR+cNmdf5gvRSlCG4BMS`eI{pLz&fFJIqnr5 zCqqErR+hT&B+3$hxaRi76EQ8gif4L5mEhcz_Y+Q}KQK}$sV+x$%EN{UdBCg=EYdAS zUm9;Hd7fDEsSu>a@bK^7bY-OrwF87rGR!^VHx`(9JF&~LWWlDcGU~PLh2ZuFvizMnBDcHO> zy2fDg{s?tRk^7H?PPZ|Gb0keya!wyLh4WpVFxs22%C2LGSc&+E-eYo7*P<*eTT$5q6N6 zenCqA^zd+%;58_&$Ul!+QbtcxKjlJwxwtv*Jp4M?F8&cCFnm_@FVa%pi{|Xg)?Wv( z+!?|SwB~ONp%UzVFBMqs*t-kMbiJauRBu4<8mpA_liN$4H^`fiV!NBY_oh}^p3$05 z7^lz3aDIl#8g8~}plC_p>9l-m0hQ-~1a3TTtl0Sw?O}}yB`F{#RL7QOl1Dnrv3KNm z2|-sJbGeXTBBO0GSY1^t@IxQp&iwIcYDp3wE+gmxcSF;pHQCF(sX7BXbkR*gn(!pQ zv*a(YA)ux&3Xz6jLcEnj%2b%>f6ZVbm@g|_)hTZ#?YO~MIK8LMnK6C z{ra@JkCs(Otpr`Qg(GAlgO7kj`|r|k%QBm{X5YnmWz23@`9j_;TFl_ibJvKzlk3`} zo$2cyG5H4elqF6%tz5A6l!!AR?=7zVFEXDNc3$8^T7W5r zCGHONT#w6KC)H-CPx`dH%${1*wGF6EusG-?Of=-b)^&mT!k<`r^T}TiGIxRfk#RU_` zn_Axsxr=N4&Nk;u@OLlk!QE+vKW<>9Sc1cDi4CF2-kkXplzE8sAGa|Fd-hK}Q}BK8f%Lk=vd(c7IP`qXk0@vpdr3sn0T!Tmq`oVJt8X#&WXzLF*_r#qN;Ejr|2ykLDi5q76E2{!){jhlz`dhBIw)Q{G$Ku7*Ezf-nf zI%Ykoe|5b*&+Tew`UZdGWjjr>&-1x?*@Y+;9OA3GMz&5+l6XgPiBk6LZq|)Kby@kk z>!!doYwFqXQ1lox0rTEOOe*oDZTCAm)8vW8>@^+ipJh+lFKXLyXpa?ula9l4GikOHVli`fWP4?do4dhB0L26Uykj;)WH@heO<5&U$YgwF@3=6}O{G*4BjoBnX61 zey|v#C%v&7@1X|h$$+piR}Cr~d^cxD3d(s*o2fsn7{;Z!uqS}ts0MOQ100pBIr@ls zdOUbmM(=Mva1HVuq2)KI$6lQ()rOCrsDG68}R3(5S;XE2R^cM(;G7mkT!rL2JtEi;t z`0xCY5=XQi9Y>>)dIG0o$U9j8BqmXImAA^zvUeZk0%K=6|A4Af(Z{p`HWy``%n(nr z+kWF3e&FpH_; zN!8xlup)mmpR-^1p`@7;y*J>4xC4ANxNNfJ#fZCmhCtYG#1@RhN@*^7P^ z0-QG$m;c<8>|2!?Ska(pj$3(NR7$baa2(58e&+k!u|tilVTiygG`;#n6-I8}&!74F zMbz%1QF)Pg_b8*LEZYk?i0m1%r_^!~oCz*_cReS!Ec5Jn6Y5)IYREi=>fS1{9|p1K zYKMKoANx3;d?f$g99Fb`LI5|z#Q@&Nc!#n!+XA`C>l5NUgV15)kVgCTx5581Psx!# zv8w%qydeP-4Qg0Zrd5fTewtBF(TJnb0x~V9lK?=~{Log5HnB6GZLK zt0CIh!SEz2#m&LBjrIw4H#@F&+cQ98eP-?uu->F?=yBQC>>J&ru+zoq-R0&^^Zx(h z0*EX%RA^Njr>3S`xd5}iqKB4epBE6@<)3}{>%t-+9c(U#xttri;r#WQ@ewSR1pm9q zgoot37UzEbd@q#GcyJl!rSyqM+iZFEYU@GzJ!n`)6jya`deM#R@%y4y84_b))shrS z{oC2=XslD|>1XP1in(KD?gJ9KMD?(vE%*_sAkd3-#;ws+j$8X_ZQBIZ8KXk2tTQBg z9s>W64{}y2II(*0aw8H&j3Ad#1nOCo=^hzT>QAs6s8Z@7q4PwW6E(i4!HJS}e5zEC zfKVK}dCKRda(PPs*YA(V==pNg zgBYmzmlPv%xd~ICpWwDs>@x|=J1gho_^#yLAeb#GEGd5!J4=}qW^b+)BW{W2cNW}wOMm1rIeB!x&7zfFkL)1kNm$cak{6`eGYygC^flJ@QC^u zY-He$s_gI&QPvWQQ`trt=o^}FqLNfUljCPUx$*vbOjoib>QvB~RuP)le5pH+7sfnJ z5RiYl@|h}na>X=TNbrAsx0bA;^wCIloFedBY=Rxc$2c)}Eq+;T1$d_pSpsz_-GtRr zACY)lI=;OEuiX&3wU^_~ZNwhwg39A6sr!v~L478FB1B7Bf9wFUzrK`q{8KhbC@!4k zOs=}YAG9DOb3kS>z6i*hSNjN?(>@&h9*l{-Dj|YA*HwD|{!qG=w_)5aSn}>jx!ObG zuTREG!*MTZ3K5R~7j17D71i6m4bveFN(u-fhyl`qz);eNAR!GC-@*Sue2}1J*?|Voleb&|Dl0ha70e%5$lJ*VS&LwE9e|`8hVe32HWV&_3R%DhH ziS|jIZpd(`Zy!2#9K`n>?XP|R^?~b7(7bagc^(bzh-yosonhL!d`S2ro6iFEp?9t04jVFC0{8$r$0bphKc4tsnD}SiZ#;lNtvmkCo|xj-M&#Un?jO zzk-U9r5Cj``n&vu{s&~LAN+%hfI?LMRr(I}yLz{QxfJ+f`UzGR(?~MrtbbIVKa*}o zty;p%EPAkP0hRsulL-49#D9yHQrow=eOYI-(R}Wn)Zbr=kTiM7+=vbF&q75nd}%G* zCvHOXJ>mwC_0ntxa#4;-ap8sw^{^cB_v@Nq^Yca87QbtM~3n3OmVWn8>ED1<6mRo=Pd zbW_Nm9SMsSEIo}90t!x}hLfRNbp6!PIUHR+GRtOYbmddBQzq2>TQ4!Cwp?7);yHgy zHnHh(z0v=TOONS|M^6z|bX9(}nGefRx(r;N=>zM7(H=;2wP#yg7w?zXz-EAUR+ryP zdmaDt!>v1my0w7*-~Shd|_bUFPnxAz~m_Q{fre&C-pkaju7mvyG5LXkC`$g@c z_(xxP+PD_;*p?!wm%;O0EYddB-wfq5pN;M}xJdes4O6^7*T3y62Nd3<6DUojKCI^L zzRmQjtOhx*J6~}g+0L;1xHVG|(Bp|g+Ex+d+IUgUk27C-0Wo{9EsK%QiBbHI%yVpL zOeGgx(wv5hje2ACRb1n!ubZY(_*PFSv%3i

O*0cP|PRte=zJ6+d$&o^st_m!)`-^~uUca&S0!kh9Vfi{!_w}h4^ z%}&j0ryI@v!xbASxWwJQUnnU%G%QGHBDSMin)W(alvgxB_N)i@hny?R5ke%*+>`d? z+mf zVNWw*nwT;0I{3gX$>wy#|A80TNAj=mKZ#a@decq`#%=r?e`n<$ya z7wymN$1q<~RHqt39jHc{!-ktz+z7?+|1mf?5I05z_#FMht9^{8g0x9X{7<<4fitEd z6o&t{?O#J~(JCjT+4tY~c7Z`Zz)P(w-RVZFE8T);{C~UGckxJsHS(n)p>FpN|G!aP z?A703lvsX@o0`(kA3&*a$9YZXt5ynO)t19o+ffd!#HUhZ^+cPLuqTk(wG5qzsT}PDTO&O)-_oHquTBv2BMyA=h&lAf1w>VGA37(by-YPd?0GZ#pXp04{uQZNe@_!@BOgV#v@k1%1T&XhB;0+s&siI( z;SL7anMDg|?6MVZDT-Xyzwi4?S7-oN`MouYxygD6>)d;I5z;yB%T}w0(xmq~xDvNy*>F35%#~e$7e9&Xuw*K>l!+JANFMjH6x8 zPD&dg8}eH19O8rw;C*{LOS8}hNAUsZ?oI6gbegs*@QwxZT5Y_>176w~^03D-+_b3t zmqHD3JF5(D_|6Kjj7;^i&vplO#P|hV6&~lj#iRONK#U%u>KnQCL_bAt98#Op0Yi#h zTpBguQ?SZ9CsrNgEYMdTMt`(u0&F6$Z8o^4+bn=0vUGEalp_od7j8EgjO&V9w(nDyx{vnhe zfYoh6q97<2n{oVNRhg~x30-GhZQT0GNN{9@iC962F7!>Z1>Xp}*tcpXt95^nWV`=b z{=_;t&sDgD8WA6U_Ku+=y1UpT`FrALDXp*o6iJ%BtZ#Z zdftMh1H(>}Fg$(%JhdHh2lQdET7(R$tag;+)wzbA-D|@@?BI4%d$NIikA98)s4a1| zBDZ^dt(Ykk_pY}UL%VdLECNH8U& zv=(00uraf64mfxo=F!<4h+GbRUwB&nXTP-m3Bnr=IN6-`Lq=vz@>AWOmQ~r4!#BpD z)69Mcu{)cZK<7KKq4Be_Hx}2LM5d)u5o$;(+UP(@NO=r0h1=u~0xb=9=ymPR9uzzs zYVrYNYY1%anfl#b1;?DwC#t;c$O@7~*)T;#9&>Vp_p4Nr=8JxIC5r0$lBzmIvT{MO z%TVg%1QLhdws(p>)FsX#Whyye#QRM?PC$?4eYm}lH86JEd_lDFgdhsQ>q4-}6Fx0d z-Spv?<%V8 z_sF27IkYfVz{BIqRZqqe^`cWX1&z_vU7A0MEmE-&^}ST;1)_wGJNUh^vae#e0+nJW zRe?bW;KAdSbUfFNAk)Xc1rmPh`8eh72L+o9=~;CFVy=*$=L(@NG(ik*px5;BoQ^1j zOcX2*?H}F}HJg4hew5)lSRbp#PJa%c8Cg5HN_R#f`ge-UKi0P){RksZr-Dl~c)rX{ zZB%XN^OZMW6`75`z0zRyNb^)x`NwfCCi>@h(nI+K`+m}DZ3TSjb@?R8Aw&ZZEVsB zMkNrkXup%`CVHk<*u#F}G=|c1K?QtDG67SD61fI3eXYOln57bqnU&;p%!Gt>bsjQw9W97c3a(1P-0F}i@KT6l% z=J0VXeNfaOf|rE44RtDPa3A4)n+LT4KBr6#6%dmizg=W)(0~#*QAbHE0!2_uD|#_& zXs+rN7`g!kCH3oa>yC3KbiU6S3I`Jg?cBF%zdKOHhvHgA3<<0mokWg3OqEjqv{4P2 zBJF!eU4%nPEP`(9tK^1221?&$8GDAnY!JOfPh)#5@TF+zdDngK$)B9ycEXziOc|AC zjX`|Ux2rhy#-p+5phUukyJDC`*1WNIW*z_d{$x_>j++p}7|3rzOTzqPbTeovsSpmH z)}bvBBod&j;1Il_>Z6YI7^;RUmR-A`uaq_0W&Lq@9*`t~l)xjPBI??cxd{V%*0u8&VQMI|YN#l8Pvn3X z34M|?6@5Ys$L>=sLQT}#yz{QE<1)N8t9I>|T@%PPTLe$AM43cU61tNJUm6^qFrt3I zH>vb_ll_Q=e!wHlN8OCJ(w*$&bx9F|RGXdZ*N`}KA*G_ii^Fqs;PPUsiP_*6l5^8- zwHBaR!xU`-Q{$SyA~&_?L5etVr%b~5xY&>0^x{$NFTANO(0x^Ma5x8F>_{zK?!zYZ4_WBi1hSFEaM)x++$NYW{2gg}8TrbL z;f47Kb1f{0{vvmw5KL_rnY`ii8t9O0yw3(;C^da zKumdE01>hgb$-|vtU7t6dCgg4f_}BQGJ+~bYD&I@T{wFkf)nX!8MW(T+Jf69_@p0@ zB&PFHY4LbohN_0;l==_byxf=Um zcv8Ye&7#+<*fg2aY_`Qd>YnrbF2>yKO17Qh=_?u~ln1e{T0HhKLV@91e+W%bq=oModD#7_e``H6e>)eh^m#u)blWNMe0PTB1L^@%>2yVbvld+6y;J7HWpK$@cz4c5WUYAD!$C!RMLYNz zWV1K=YmlPgu%xFfMl$$_c+MyIZatyuj_K`+8e4p9{@?GLGZmp;KN9E6MP0Fcs*orb zWLjI3CEyaeGG&Yo4DKK4!L_}aGK%U8IGuPD_cZo#y|N+e)17#V=+hT&*;;)(V#*aO zV66_lzhJRgWR@&@7O0AjqOT{AC(0JpD5tSGjPYV&>l*X58bxYLq%>#LE~rE z^?x-~<@{D8_VYn3~OLDwlJkD>r!8YNNhMY9Pt#JRsRoKc0M^`dQj*ghqvJB6)3&-`}_i=el%6v9M9l1hdw-{1)fj!1;3ft}~@E&TBoxcsirg^A8U60)2cbb^O> zq3T}a(Bisk((GB3==uiQYQjnr8a?zD(tYApj%?GaDjV$t1?YclMLDu6`u^F{UW2 zwf*;!VloqpD&7z|IGK8#@L5rg=IDyYg=_~P)4QCQoHJp%Y9rvNQ0f6sH23@a${W8E z5a40&7p>yWf$?6Xow5V5wKu`nds0UtE~UW#F#2WsIrLBDpX^oc%PF<4CoR9@fPR~_ z$vH6HyRFNs{!Dp&ZnrYM`gJ=aNUdOu=`-?=^w3?S{V?3X84N;RZ-D2Va2LiQ8Nlig(m>_WA|{!yM~b5- zR$TJ{#BHe>l@a~gH?%3>BD!M(g8cMqDn%P=*ZV|%*fJ+9yJFOKetS0nO)1xA=mNyJ z_O^PVZ%c+i(+*yOoTHb&zgIev{Q(N=zUzS&C)#`B5I|tYw0_Fwn4tsW=weI_9Nw%7 zpP=)TP!}Opk_RxyK<4?3F9c5*5s&W6dp#Hn?#U^*wML}yH(9CY^-mV>&WuWgzhoiXkzWS0QX=I0$GG!Sw;>OkG|%T5ex zq5uhRS+|FWupcB#=ZrKdku+u;IYGl*Z#=JiZEW;h!D;W??bmOCAH@Dm-mf1o9u(tB zi;3z9tp)+dBQ#)R!M<|Qf7(1f*S9NnN)0{gcH`8+-Psm;+gthKL`mc{+Qt$8Mbce? zUo+_?VX7bR2W36RGBbXd0qBLX{~|bTF5GXs8*tCJdHP-3TLDqoC9x?5~nH z>(7Yg{j+m`(L8140ppD6k3st>bq<^S6l`yJaUI6Tfm{=sM+gn)Ex#Q4jpku1a3q#M zyg^_^en*{3JAC2LJ!d3BkO&`n&%a|3p5t?`2^F7pxB{=muys5r?}aK|1K_stIf{zb zg}xe!`tmC6!@O4zJ&1})23T;KJ@6P;*HodSH#|-lu@BSG z^C3)ai0tcOx^X-{jvB6~aVtKpAcEwsr~&^qs40jV(Rt~~sR-U33FEZ`$V>V6=jA&E z`^q!vS7;0G^ITgl)-d&!!6GGZ$2)E6z_~uZF~NTD!)yZ}>3O;ZI>NDJmpNh3WN4tL zwHpCz78P5Ihdi7G7+sc77s6tg4`g51{gBXfkdJp+vB&jF4F!+Am@rYA_sj-5+pF_F7T9}HSjy{kNNYR zOVZ^&^yYZQcB*x+dQ*>sB(d-X6$Nd(;LR!p)M`LvbMDh->X*+GuJDEwklOVt>YK%a z($PUIo51FGhc~}v@G{4~2Q{l3n6!2V`5#1BzHHha&C~MKx@2*CMQCo--Z~ll_9bf` z0UZryRdgpYVGmw>k-6T@X_zC+wsP`n6wvi4#aeW@q-MsVf9j`Eib;Z&#)3R*Z^2z4 z;RAQJYrw*dv>wsBKTO#Ut;5qkGcICYQrZ@w?jes&*4ECB>r)TXsNAQ(&@Jg@BNAi0sS4{mjZm8gz*SO}a?YBILS?0k?A_2#T`wot}R7TLy^ZQ4)dKOA!RZ4`o1PzmiEccrhkm)4%$37-+CYb(%NaD%>3;I;f%lFaU z#CBhF;I-ZAiAnvK{hkzF1ef<;(uzoYAC8N_ZxC4mzCBFaoS8?)eU}xkXw!>L7a+e# z@$rjYpq(+@Y#{F^>dmYDu|{|LWZY<^z6HAg$xHZNU{}Y|pUfFM&)u5EOMOqtGjzf7 z8OJ1jm(CA`D?)!#zaL8qki4jfOK-LVa||qoLoU5Tiun{kOdU_O>EkB&bOWOG(GDiB zLhlsQB4cXrDP^-zcNLy2o*Fn3R=ebY#4RlK@$b@?|vjy29- zQWx)}Z+#s_9_k^Zk|V@%{%;@OM6o`g$yCAezoqwh!*TSF#Ar%l+!8s`OdRoIRK+K9 zm_tE{`Hyvy?@C*o(~8~_Gr1qM4Qla>kp@? zXJFnHGe??$_}G6CkLliHhPbR0n1$ZNO!y3lUhjP})y7>phcW=OdMyX_#5tB1No-Mt zo7Je;O|;S1lxs%xX5Re$i1o7Q0xtNgL^y^EeYfc7H`$iBEU*N|R10^-b(lYWDlaLx z$=f6$78x{nfYh2HXaR?e;2S&&ojvTMD~bfF9=uZTf2c{KAC`eK<^1drBJJC3@)k7? zAbm?lhoNiLysjfoPIV+co20Oh2uc<rlC~pBVzqSQl&?uxes?)?Ly8*S;GMi1wqqICS~F?KlM9_ zAJUe$80$#g5Qpy(^co3_z@&zuo)d&O6L47+sFt?yKI@8ogC>C_GF8+(to2Xx_2D4nmYXoC>=_s55kuRaUtw31BxAff(@bY0%z zJw{)Rz&+*Mhj_Fg&%WK`P$W0dGy;jhtIUO3y?cxSpMLU%p>>5rz4{=8hI}%8zr0Ch zEKiH#mc=0oG(w3I5Q@sVCXU?M!*^jGxaMwH4CGy4v12Oc$|Kf>a$VKS_+aJJ>l-{ zVy4(MVI(cDh!zx8-H(crkg1!-ZGYN#4eT}H|1wp#$-Yb&-X7scwTtY4ydKW_`lsH>BBMwcm_t zvlz4ON7>3p9n zDlGr@FYj}(9+%omV+H1XTUmG7hSFe~iT0jK)DfR89SIG6O5x1g6|2G#i=_=_j)aaE zsaN2*aF?ThN(2a^M8}c88Bd%ZjAu=rR*NJSU-g+Lmy35fJ(#kYL>n^Sm&Od^bG1yK zM04D`SB773X5an(ag{lsrd>FeVBjMOx8%$N ztptmr6AzmY;w5VsdGW4|xt_;o(klSG8D3r=<*{b7{)gV-57#`K=rMk)Yb^+s

fb zDaj}|I&P*ri#xZ^F369OE3yV84xK8)6C1LDJ>>>v=+&W;;qgiby$Eu2_|V5GjLK#h z-23T02z^?%rBU*piCX|nmXuKz#D7B-Q4d0mn$CmMiDxxQmz}?fcfTweku3L>`Ah3cKv{Gz-lH~U&Zt^UySP&%td^c?4X3ii*h1SQfy!|p-D ztE*HZZW*^N0D9BqG=G`~pL4C$uVr}DVk?WzSN1@IHpYO#=Fv<3uP9CI0tT__+J^(H zlfUTC?zuc3gy9VAbOBKJL+GyPO-z*R`4>VLvIumLufQQ<4MxE66835(xK{mm`*;_X zo~AdBoK9z$_q;lUSSx8aB32HT{74Sc&Px`zC~bbaI^(XlK1H4D|E4~|q{U2ocv5Ay z<#kb+K0<995&W@PxTQ&ph_?7+s067yf{Nx`fJ97Q$F_Aa^=sK zlQb00et^wjyytpFG;|Oxxy$99i`t)EJn%Y%yMABhTB70R;GP5VJ{y7(P+c$>MQi=knZI%EHyM5QEssa5U+ zY+A{MPoe;P&QrN|{|k)Rd6@c$krzi;xj1q!)6;s|26?DQ!}TVoO5af9{>KHp0gMPH z8=iFF4CdDJkN}0*6xeyMU0xiIH?YzAJ8F_^>9;+W9pO^8TTd8#yR7+&c3IaJy%aO@ zrG)K#1S3SmY6dwy%!}iZ+=*t7uPi9=bl2MyiBpPcCj8#Di+&!aXD1keUK>*Mi}+>i z1Ue+!simWexaHDe>Z8rpR$fV6;?v_WO6X-!c@~%0DGv{P&NAxYda*&yam421msbbB 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

eh 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

^!rEB}z+z%1S}CDJ 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 kYc;+cz#{(_b##xjm-TGbMkvr23HVWzRg 2: + try: + test_num = int(sys.argv[2]) + except: + is_file = True + +if is_file: + inputs = open(sys.argv[2]) + inputs = json.load(inputs) + actual = "unk" +else: + data = MNISTDataset() + inputs = data.test_data[test_num] + labels = data.test_labels[test_num] + actual = 0 + for x in range(1, len(labels)): + if labels[x] != 0: + actual = x + inputs = gray2rgb(inputs.reshape((-1, 28, 28))) + inputs = np.reshape(inputs, (28,28,3)) +input_image = {"instances": [inputs.tolist()]} +print("Sending Explain Query") + +x = time.time() + +res = requests.post(endpoint, json=input_image) + +print("TIME TAKEN: ", time.time() - x) + +print(res) +if not res.ok: + res.raise_for_status() +res_json = res.json() +temp = np.array(res_json["explanations"]["temp"]) +masks = np.array(res_json["explanations"]["masks"]) +top_labels = np.array(res_json["explanations"]["top_labels"]) + +fig, m_axs = plt.subplots(2,5, figsize = (12,6)) +for i, c_ax in enumerate(m_axs.flatten()): + mask = masks[i] + c_ax.imshow(label2rgb(mask, temp, bg_label = 0), interpolation = 'nearest') + c_ax.set_title('Positive for {}\nActual {}'.format(top_labels[i], actual)) + c_ax.axis('off') +plt.show() \ No newline at end of file diff --git a/docs/samples/explanation/aix/mnist/requirements.txt b/docs/samples/explanation/aix/mnist/requirements.txt new file mode 100644 index 0000000000..ea9d3554ed --- /dev/null +++ b/docs/samples/explanation/aix/mnist/requirements.txt @@ -0,0 +1,103 @@ +absl-py==0.9.0 +aix360==0.2.0 +appnope==0.1.0 +asgiref==3.2.7 +astor==0.8.1 +attrs==19.3.0 +backcall==0.1.0 +bleach==3.1.4 +certifi==2020.4.5.1 +chardet==3.0.4 +cvxopt==1.2.4 +cvxpy==1.0.29 +cycler==0.10.0 +decorator==4.4.2 +defusedxml==0.6.0 +dill==0.3.1.1 +Django==3.0.5 +docutils==0.16 +ecos==2.0.7.post1 +entrypoints==0.3 +future==0.18.2 +gast==0.3.3 +google-pasta==0.2.0 +grpcio==1.28.1 +h5py==2.10.0 +idna==2.9 +image==1.5.28 +imageio==2.8.0 +importlib-metadata==1.6.0 +ipykernel==5.2.0 +ipython==7.13.0 +ipython-genutils==0.2.0 +jedi==0.16.0 +Jinja2==2.11.1 +joblib==0.14.1 +json5==0.9.4 +jsonschema==3.2.0 +jupyter-client==6.1.2 +jupyter-core==4.6.3 +jupyterlab==2.0.1 +jupyterlab-server==1.0.7 +Keras==2.3.1 +Keras-Applications==1.0.8 +Keras-Preprocessing==1.1.0 +kiwisolver==1.2.0 +lime==0.2.0.0 +Markdown==3.2.1 +MarkupSafe==1.1.1 +matplotlib==3.2.1 +mistune==0.8.4 +multiprocess==0.70.9 +nbconvert==5.6.1 +nbformat==5.0.5 +networkx==2.4 +notebook==6.0.3 +numpy==1.18.2 +osqp==0.6.1 +pandas==1.0.3 +pandocfilters==1.4.2 +parso==0.6.2 +pexpect==4.8.0 +pickleshare==0.7.5 +Pillow==5.4.1 +prometheus-client==0.7.1 +prompt-toolkit==3.0.5 +protobuf==3.11.3 +ptyprocess==0.6.0 +Pygments==2.6.1 +pyparsing==2.4.7 +pyrsistent==0.16.0 +python-dateutil==2.8.1 +pytz==2019.3 +PyWavelets==1.1.1 +PyYAML==5.3.1 +pyzmq==19.0.0 +requests==2.23.0 +scikit-image==0.16.2 +scikit-learn==0.22.2.post1 +scipy==1.4.1 +scs==2.1.2 +Send2Trash==1.5.0 +shap==0.35.0 +six==1.14.0 +sqlparse==0.3.1 +tensorboard==1.14.0 +tensorflow==1.14.0 +tensorflow-estimator==1.14.0 +termcolor==1.1.0 +terminado==0.8.3 +testpath==0.4.4 +torch==1.4.0 +torchvision==0.5.0 +tornado==6.0.4 +tqdm==4.45.0 +traitlets==4.3.3 +urllib3==1.25.8 +wcwidth==0.1.9 +webencodings==0.5.1 +Werkzeug==1.0.1 +wrapt==1.12.1 +xgboost==1.0.2 +xport==2.0.2 +zipp==3.1.0 diff --git a/docs/samples/explanation/aix/mnist/train_rf.py b/docs/samples/explanation/aix/mnist/train_rf.py new file mode 100644 index 0000000000..6e1c864e6d --- /dev/null +++ b/docs/samples/explanation/aix/mnist/train_rf.py @@ -0,0 +1,56 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import sys +from typing import Dict +import pickle + +import kfserving +import numpy as np + +from sklearn.pipeline import Pipeline +from sklearn.ensemble import RandomForestClassifier +from sklearn.preprocessing import Normalizer +from skimage.color import gray2rgb # since the code wants color images +from aix360.datasets import MNISTDataset + +class PipeStep(object): + """ + Wrapper for turning functions into pipeline transforms (no-fitting) + """ + def __init__(self, step_func): + self._step_func=step_func + def fit(self,*args): + return self + def transform(self,X): + return self._step_func(X) + +path_to_save = sys.argv[1] + +data = MNISTDataset() +X = data.test_data[1:1001] +Y = data.test_labels[1:1001] + +X = np.stack([gray2rgb(iimg) for iimg in X.reshape((-1, 28, 28))],0) +X = np.array(np.reshape(X, (1000, 2352))) + +simple_rf_pipeline = Pipeline([('RF', RandomForestClassifier())]) + +simple_rf_pipeline.fit(X,Y) + +with open(path_to_save, 'wb') as f: + pickle.dump(simple_rf_pipeline, f) + +print("File saved") diff --git a/hack/violation_exceptions.list b/hack/violation_exceptions.list index 0724b5e6e8..881defd332 100644 --- a/hack/violation_exceptions.list +++ b/hack/violation_exceptions.list @@ -1,3 +1,4 @@ +API rule violation: names_match,github.com/kubeflow/kfserving/pkg/apis/serving/v1alpha2,AIXExplainerSpec,StorageURI API rule violation: names_match,./pkg/apis/serving/v1alpha2,AlibiExplainerSpec,StorageURI API rule violation: names_match,./pkg/apis/serving/v1alpha2,ONNXSpec,StorageURI API rule violation: names_match,./pkg/apis/serving/v1alpha2,PredictorSpec,PyTorch diff --git a/pkg/apis/serving/v1alpha2/configmap.go b/pkg/apis/serving/v1alpha2/configmap.go index b59c26f2b4..87cd005b08 100644 --- a/pkg/apis/serving/v1alpha2/configmap.go +++ b/pkg/apis/serving/v1alpha2/configmap.go @@ -44,6 +44,7 @@ type ExplainerConfig struct { // +k8s:openapi-gen=false type ExplainersConfig struct { AlibiExplainer ExplainerConfig `json:"alibi,omitempty"` + AIXExplainer ExplainerConfig `json:"aix,omitempty"` } // +k8s:openapi-gen=false diff --git a/pkg/apis/serving/v1alpha2/explainer.go b/pkg/apis/serving/v1alpha2/explainer.go index cb5d444e32..e1fc7feac0 100644 --- a/pkg/apis/serving/v1alpha2/explainer.go +++ b/pkg/apis/serving/v1alpha2/explainer.go @@ -31,7 +31,7 @@ type Explainer interface { const ( // ExactlyOneExplainerViolatedError is a known error message - ExactlyOneExplainerViolatedError = "Exactly one of [Custom, Alibi] must be specified in ExplainerSpec" + ExactlyOneExplainerViolatedError = "Exactly one of [Custom, Alibi, AIX] must be specified in ExplainerSpec" ) // Returns a URI to the explainer. This URI is passed to the model-initializer via the ModelInitializerSourceUriInternalAnnotationKey @@ -85,6 +85,9 @@ func getExplainer(explainerSpec *ExplainerSpec) (Explainer, error) { if explainerSpec.Alibi != nil { handlers = append(handlers, explainerSpec.Alibi) } + if explainerSpec.AIX != nil { + handlers = append(handlers, explainerSpec.AIX) + } if len(handlers) != 1 { err := fmt.Errorf(ExactlyOneExplainerViolatedError) klog.Error(err) diff --git a/pkg/apis/serving/v1alpha2/explainer_aix360.go b/pkg/apis/serving/v1alpha2/explainer_aix360.go new file mode 100644 index 0000000000..c80052819e --- /dev/null +++ b/pkg/apis/serving/v1alpha2/explainer_aix360.go @@ -0,0 +1,74 @@ +package v1alpha2 + +import ( + "fmt" + "sort" + "strconv" + "strings" + + "github.com/kubeflow/kfserving/pkg/constants" + "github.com/kubeflow/kfserving/pkg/utils" + v1 "k8s.io/api/core/v1" +) + +var ( + InvalidAIXRuntimeVersionError = "AIX RuntimeVersion must be one of %s" +) + +func (s *AIXExplainerSpec) GetStorageUri() string { + return s.StorageURI +} + +func (s *AIXExplainerSpec) GetResourceRequirements() *v1.ResourceRequirements { + // return the ResourceRequirements value if set on the spec + return &s.Resources +} + +func (s *AIXExplainerSpec) CreateExplainerContainer(modelName string, parallelism int, predictorHost string, config *InferenceServicesConfig) *v1.Container { + var args = []string{ + constants.ArgumentModelName, modelName, + constants.ArgumentPredictorHost, predictorHost, + constants.ArgumentHttpPort, constants.InferenceServiceDefaultHttpPort, + } + if parallelism != 0 { + args = append(args, constants.ArgumentWorkers, strconv.Itoa(parallelism)) + } + if s.StorageURI != "" { + args = append(args, "--storage_uri", constants.DefaultModelLocalMountPath) + } + + args = append(args, "--explainer_type", string(s.Type)) + + // Order explainer config map keys + var keys []string + for k, _ := range s.Config { + keys = append(keys, k) + } + sort.Strings(keys) + for _, k := range keys { + args = append(args, "--"+k) + args = append(args, s.Config[k]) + } + + return &v1.Container{ + Image: config.Explainers.AIXExplainer.ContainerImage + ":" + s.RuntimeVersion, + Name: constants.InferenceServiceContainerName, + Resources: s.Resources, + Args: args, + } +} + +func (s *AIXExplainerSpec) ApplyDefaults(config *InferenceServicesConfig) { + if s.RuntimeVersion == "" { + s.RuntimeVersion = config.Explainers.AIXExplainer.DefaultImageVersion + } + setResourceRequirementDefaults(&s.Resources) +} + +func (s *AIXExplainerSpec) Validate(config *InferenceServicesConfig) error { + if !utils.Includes(config.Explainers.AIXExplainer.AllowedImageVersions, s.RuntimeVersion) { + return fmt.Errorf(InvalidAIXRuntimeVersionError, strings.Join(config.Explainers.AIXExplainer.AllowedImageVersions, ", ")) + } + + return nil +} \ No newline at end of file diff --git a/pkg/apis/serving/v1alpha2/explainer_aix360_test.go b/pkg/apis/serving/v1alpha2/explainer_aix360_test.go new file mode 100644 index 0000000000..b5a627ea57 --- /dev/null +++ b/pkg/apis/serving/v1alpha2/explainer_aix360_test.go @@ -0,0 +1,169 @@ +package v1alpha2 + +import ( + "fmt" + "strings" + "testing" + + "github.com/kubeflow/kfserving/pkg/constants" + "github.com/onsi/gomega" + "github.com/onsi/gomega/types" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" +) + +func TestAIXExplainer(t *testing.T) { + g := gomega.NewGomegaWithT(t) + allowedAIXImageVersionsArray := []string{ + DefaultAIXExplainerRuntimeVersion, + } + allowedAIXImageVersions := strings.Join(allowedAIXImageVersionsArray, ", ") + + scenarios := map[string]struct { + spec AIXExplainerSpec + matcher types.GomegaMatcher + }{ + "AcceptGoodRuntimeVersion": { + spec: AIXExplainerSpec{ + RuntimeVersion: DefaultAIXExplainerRuntimeVersion, + }, + matcher: gomega.Succeed(), + }, + "RejectBadRuntimeVersion": { + spec: AIXExplainerSpec{ + RuntimeVersion: "", + }, + matcher: gomega.MatchError(fmt.Sprintf(InvalidAIXRuntimeVersionError, allowedAIXImageVersions)), + }, + } + + for name, scenario := range scenarios { + config := &InferenceServicesConfig{ + Explainers: &ExplainersConfig{ + AIXExplainer: ExplainerConfig{ + ContainerImage: "aipipeline/aixexplainer", + DefaultImageVersion: "latest", + AllowedImageVersions: allowedAIXImageVersionsArray, + }, + }, + } + g.Expect(scenario.spec.Validate(config)).Should(scenario.matcher, fmt.Sprintf("Testing %s", name)) + } +} + +func TestCreateAIXExplainerContainer(t *testing.T) { + + var requestedResource = v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "cpu": resource.Quantity{ + Format: "100", + }, + }, + Requests: v1.ResourceList{ + "cpu": resource.Quantity{ + Format: "90", + }, + }, + } + config := &InferenceServicesConfig{ + Explainers: &ExplainersConfig{ + AIXExplainer: ExplainerConfig{ + ContainerImage: "aipipeline/aixexplainer", + DefaultImageVersion: "latest", + }, + }, + } + var spec = AIXExplainerSpec{ + Type: "LimeImages", + StorageURI: "gs://someUri", + Resources: requestedResource, + RuntimeVersion: "0.2.2", + } + g := gomega.NewGomegaWithT(t) + + expectedContainer := &v1.Container{ + Image: "aipipeline/aixexplainer:0.2.2", + Name: constants.InferenceServiceContainerName, + Resources: requestedResource, + Args: []string{ + constants.ArgumentModelName, + "someName", + constants.ArgumentPredictorHost, + "predictor.svc.cluster.local", + constants.ArgumentHttpPort, + constants.InferenceServiceDefaultHttpPort, + "--storage_uri", + "/mnt/models", + "--explainer_type", + "LimeImages", + }, + } + + // Test Create with config + container := spec.CreateExplainerContainer("someName", 0, "predictor.svc.cluster.local", config) + g.Expect(container).To(gomega.Equal(expectedContainer)) +} + +func TestCreateAIXExplainerContainerWithConfig(t *testing.T) { + + var requestedResource = v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "cpu": resource.Quantity{ + Format: "100", + }, + }, + Requests: v1.ResourceList{ + "cpu": resource.Quantity{ + Format: "90", + }, + }, + } + config := &InferenceServicesConfig{ + Explainers: &ExplainersConfig{ + AIXExplainer: ExplainerConfig{ + ContainerImage: "aipipeline/aixexplainer", + DefaultImageVersion: "latest", + }, + }, + } + var spec = AIXExplainerSpec{ + Type: "LimeImages", + StorageURI: "gs://someUri", + Resources: requestedResource, + RuntimeVersion: "0.2.2", + Config: map[string]string{ + "num_classes": "10", + "num_samples": "20", + "min_weight": "0", + }, + } + g := gomega.NewGomegaWithT(t) + + expectedContainer := &v1.Container{ + Image: "aipipeline/aixexplainer:0.2.2", + Name: constants.InferenceServiceContainerName, + Resources: requestedResource, + Args: []string{ + "--model_name", + "someName", + "--predictor_host", + "predictor.svc.cluster.local", + "--http_port", + "8080", + "--storage_uri", + "/mnt/models", + "--explainer_type", + "LimeImages", + "--min_weight", + "0", + "--num_classes", + "10", + "--num_samples", + "20", + }, + } + + // Test Create with config + container := spec.CreateExplainerContainer("someName", 0, "predictor.svc.cluster.local", config) + g.Expect(container).To(gomega.Equal(expectedContainer)) +} \ No newline at end of file diff --git a/pkg/apis/serving/v1alpha2/inferenceservice_types.go b/pkg/apis/serving/v1alpha2/inferenceservice_types.go index fd94e7b1bd..1be065b1c1 100644 --- a/pkg/apis/serving/v1alpha2/inferenceservice_types.go +++ b/pkg/apis/serving/v1alpha2/inferenceservice_types.go @@ -129,6 +129,8 @@ type PredictorSpec struct { type ExplainerSpec struct { // Spec for alibi explainer Alibi *AlibiExplainerSpec `json:"alibi,omitempty"` + // Spec for AIX explainer + AIX *AIXExplainerSpec `json:"aix,omitempty"` // Spec for a custom explainer Custom *CustomSpec `json:"custom,omitempty"` @@ -167,6 +169,26 @@ type AlibiExplainerSpec struct { Config map[string]string `json:"config,omitempty"` } +type AIXExplainerType string + +const ( + AIXLimeImageExplainer AIXExplainerType = "LimeImages" +) + +// AIXExplainerSpec defines the arguments for configuring an AIX Explanation Server +type AIXExplainerSpec struct { + // The type of AIX explainer + Type AIXExplainerType `json:"type"` + // The location of a trained explanation model + StorageURI string `json:"storageUri,omitempty"` + // Defaults to latest AIX Version + RuntimeVersion string `json:"runtimeVersion,omitempty"` + // Defaults to requests and limits of 1CPU, 2Gb MEM. + Resources v1.ResourceRequirements `json:"resources,omitempty"` + // Inline custom parameter settings for explainer + Config map[string]string `json:"config,omitempty"` +} + // TensorflowSpec defines arguments for configuring Tensorflow model serving. type TensorflowSpec struct { // The URI for the saved model(https://www.tensorflow.org/tutorials/keras/save_and_load) diff --git a/pkg/apis/serving/v1alpha2/openapi_generated.go b/pkg/apis/serving/v1alpha2/openapi_generated.go index 38cabedffc..37f755659c 100644 --- a/pkg/apis/serving/v1alpha2/openapi_generated.go +++ b/pkg/apis/serving/v1alpha2/openapi_generated.go @@ -29,6 +29,7 @@ import ( func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenAPIDefinition { return map[string]common.OpenAPIDefinition{ + "./pkg/apis/serving/v1alpha2.AIXExplainerSpec": schema_pkg_apis_serving_v1alpha2_AIXExplainerSpec(ref), "./pkg/apis/serving/v1alpha2.AlibiExplainerSpec": schema_pkg_apis_serving_v1alpha2_AlibiExplainerSpec(ref), "./pkg/apis/serving/v1alpha2.Batcher": schema_pkg_apis_serving_v1alpha2_Batcher(ref), "./pkg/apis/serving/v1alpha2.CustomSpec": schema_pkg_apis_serving_v1alpha2_CustomSpec(ref), @@ -56,6 +57,64 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA } } +func schema_pkg_apis_serving_v1alpha2_AIXExplainerSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "AIXExplainerSpec defines the arguments for configuring an AIX Explanation Server", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "type": { + SchemaProps: spec.SchemaProps{ + Description: "The type of AIX explainer", + Type: []string{"string"}, + Format: "", + }, + }, + "storageUri": { + SchemaProps: spec.SchemaProps{ + Description: "The location of a trained explanation model", + Type: []string{"string"}, + Format: "", + }, + }, + "runtimeVersion": { + SchemaProps: spec.SchemaProps{ + Description: "Defaults to latest AIX Version", + Type: []string{"string"}, + Format: "", + }, + }, + "resources": { + SchemaProps: spec.SchemaProps{ + Description: "Defaults to requests and limits of 1CPU, 2Gb MEM.", + Ref: ref("k8s.io/api/core/v1.ResourceRequirements"), + }, + }, + "config": { + SchemaProps: spec.SchemaProps{ + Description: "Inline custom parameter settings for explainer", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + Required: []string{"type"}, + }, + }, + Dependencies: []string{ + "k8s.io/api/core/v1.ResourceRequirements"}, + } +} + func schema_pkg_apis_serving_v1alpha2_AlibiExplainerSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -270,6 +329,12 @@ func schema_pkg_apis_serving_v1alpha2_ExplainerSpec(ref common.ReferenceCallback Ref: ref("./pkg/apis/serving/v1alpha2.AlibiExplainerSpec"), }, }, + "aix": { + SchemaProps: spec.SchemaProps{ + Description: "Spec for AIX explainer", + Ref: ref("./pkg/apis/serving/v1alpha2.AIXExplainerSpec"), + }, + }, "custom": { SchemaProps: spec.SchemaProps{ Description: "Spec for a custom explainer", @@ -320,7 +385,7 @@ func schema_pkg_apis_serving_v1alpha2_ExplainerSpec(ref common.ReferenceCallback }, }, Dependencies: []string{ - "./pkg/apis/serving/v1alpha2.AlibiExplainerSpec", "./pkg/apis/serving/v1alpha2.Batcher", "./pkg/apis/serving/v1alpha2.CustomSpec", "./pkg/apis/serving/v1alpha2.Logger"}, + "./pkg/apis/serving/v1alpha2.AIXExplainerSpec", "./pkg/apis/serving/v1alpha2.AlibiExplainerSpec", "./pkg/apis/serving/v1alpha2.Batcher", "./pkg/apis/serving/v1alpha2.CustomSpec", "./pkg/apis/serving/v1alpha2.Logger"}, } } diff --git a/pkg/apis/serving/v1alpha2/swagger.json b/pkg/apis/serving/v1alpha2/swagger.json index b6ccbf8a32..2e8da0079a 100644 --- a/pkg/apis/serving/v1alpha2/swagger.json +++ b/pkg/apis/serving/v1alpha2/swagger.json @@ -113,6 +113,38 @@ } } }, + "v1alpha2.AIXExplainerSpec": { + "description": "AIXExplainerSpec defines the arguments for configuring an AIX Explanation Server", + "type": "object", + "required": [ + "type" + ], + "properties": { + "config": { + "description": "Inline custom parameter settings for explainer", + "type": "object", + "additionalProperties": { + "type": "string" + } + }, + "resources": { + "description": "Defaults to requests and limits of 1CPU, 2Gb MEM.", + "$ref": "#/definitions/v1.ResourceRequirements" + }, + "runtimeVersion": { + "description": "Defaults to latest AIX Version", + "type": "string" + }, + "storageUri": { + "description": "The location of a trained explanation model", + "type": "string" + }, + "type": { + "description": "The type of AIX explainer", + "type": "string" + } + } + }, "v1alpha2.AlibiExplainerSpec": { "description": "AlibiExplainerSpec defines the arguments for configuring an Alibi Explanation Server", "type": "object", @@ -235,6 +267,10 @@ "description": "ExplainerSpec defines the arguments for a model explanation server, The following fields follow a \"1-of\" semantic. Users must specify exactly one spec.", "type": "object", "properties": { + "aix": { + "description": "Spec for AIX explainer", + "$ref": "#/definitions/v1alpha2.AIXExplainerSpec" + }, "alibi": { "description": "Spec for alibi explainer", "$ref": "#/definitions/v1alpha2.AlibiExplainerSpec" diff --git a/pkg/apis/serving/v1alpha2/v1alpha2_suite_test.go b/pkg/apis/serving/v1alpha2/v1alpha2_suite_test.go index 652429f496..ae57b20d42 100644 --- a/pkg/apis/serving/v1alpha2/v1alpha2_suite_test.go +++ b/pkg/apis/serving/v1alpha2/v1alpha2_suite_test.go @@ -46,6 +46,7 @@ const ( DefaultTritonISRuntimeVersion = "19.05-py3" DefaultONNXRuntimeVersion = "v0.5.0" DefaultAlibiExplainerRuntimeVersion = "0.2.3" + DefaultAIXExplainerRuntimeVersion = "0.2.2" ) func TestMain(m *testing.M) { diff --git a/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go b/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go index 62d192188d..ae396e9f2c 100644 --- a/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go +++ b/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go @@ -26,6 +26,30 @@ import ( "knative.dev/pkg/apis/duck/v1beta1" ) +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AIXExplainerSpec) DeepCopyInto(out *AIXExplainerSpec) { + *out = *in + in.Resources.DeepCopyInto(&out.Resources) + if in.Config != nil { + in, out := &in.Config, &out.Config + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AIXExplainerSpec. +func (in *AIXExplainerSpec) DeepCopy() *AIXExplainerSpec { + if in == nil { + return nil + } + out := new(AIXExplainerSpec) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *AlibiExplainerSpec) DeepCopyInto(out *AlibiExplainerSpec) { *out = *in @@ -174,6 +198,11 @@ func (in *ExplainerSpec) DeepCopyInto(out *ExplainerSpec) { *out = new(AlibiExplainerSpec) (*in).DeepCopyInto(*out) } + if in.AIX != nil { + in, out := &in.AIX, &out.AIX + *out = new(AIXExplainerSpec) + (*in).DeepCopyInto(*out) + } if in.Custom != nil { in, out := &in.Custom, &out.Custom *out = new(CustomSpec) From 185ab97148bc24e83878ff486c2aedeefee9c3ef Mon Sep 17 00:00:00 2001 From: Andrew Butler Date: Tue, 25 Aug 2020 12:14:20 -0700 Subject: [PATCH 02/32] Add AIXExplainer to function --- pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go | 1 + 1 file changed, 1 insertion(+) diff --git a/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go b/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go index ae396e9f2c..8a68b618ba 100644 --- a/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go +++ b/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go @@ -225,6 +225,7 @@ func (in *ExplainerSpec) DeepCopy() *ExplainerSpec { func (in *ExplainersConfig) DeepCopyInto(out *ExplainersConfig) { *out = *in out.AlibiExplainer = in.AlibiExplainer + out.AIXExplainer = in.AIXExplainer } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExplainersConfig. From 4d96fa5762394f102e4586c22e028ce00c5c8a0b Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Mon, 31 Aug 2020 11:36:57 -0700 Subject: [PATCH 03/32] Add AIX explainer implementation --- python/aixexplainer.Dockerfile | 6 ++ python/aixexplainer/README.md | 17 +++++ python/aixexplainer/aixserver/__init__.py | 15 ++++ python/aixexplainer/aixserver/__main__.py | 54 ++++++++++++++ python/aixexplainer/aixserver/model.py | 87 +++++++++++++++++++++++ python/aixexplainer/setup.py | 42 +++++++++++ 6 files changed, 221 insertions(+) create mode 100644 python/aixexplainer.Dockerfile create mode 100644 python/aixexplainer/README.md create mode 100644 python/aixexplainer/aixserver/__init__.py create mode 100644 python/aixexplainer/aixserver/__main__.py create mode 100644 python/aixexplainer/aixserver/model.py create mode 100644 python/aixexplainer/setup.py diff --git a/python/aixexplainer.Dockerfile b/python/aixexplainer.Dockerfile new file mode 100644 index 0000000000..03589db3af --- /dev/null +++ b/python/aixexplainer.Dockerfile @@ -0,0 +1,6 @@ +FROM python:3.7 + +COPY . . +RUN pip install --upgrade pip && pip install -e ./kfserving +RUN pip install -e ./aixexplainer +ENTRYPOINT ["python", "-m", "aixserver"] diff --git a/python/aixexplainer/README.md b/python/aixexplainer/README.md new file mode 100644 index 0000000000..5af8492fd3 --- /dev/null +++ b/python/aixexplainer/README.md @@ -0,0 +1,17 @@ +# AIX Model Explainer + +## Build a Development AIX Model Explainer Docker Image + +First build your docker image by changing directory to kfserving/python and replacing `dockeruser` with your docker username in the snippet below (running this will take some time). + +`docker build -t dockeruser/aixserver:latest -f aixexplainer.Dockerfile .` + +Then push your docker image to your dockerhub repo (this will take some time) + +`docker push dockeruser/aixserver:latest` + +Once your docker image is pushed you can pull the image from `dockeruser/aixserver:latest` when deploying an inferenceservice by specifying the image in the yaml file. + +## Example + +Try deploying [LIME with MNIST](https://github.com/drewbutlerbb4/kfserving/tree/master/docs/samples/explanation/aix/mnist) diff --git a/python/aixexplainer/aixserver/__init__.py b/python/aixexplainer/aixserver/__init__.py new file mode 100644 index 0000000000..d51215f730 --- /dev/null +++ b/python/aixexplainer/aixserver/__init__.py @@ -0,0 +1,15 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .model import AIXModel \ No newline at end of file diff --git a/python/aixexplainer/aixserver/__main__.py b/python/aixexplainer/aixserver/__main__.py new file mode 100644 index 0000000000..2016764805 --- /dev/null +++ b/python/aixexplainer/aixserver/__main__.py @@ -0,0 +1,54 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import argparse +import kfserving + +from .model import AIXModel + +DEFAULT_MODEL_NAME = "aixserver" +DEFAULT_EXPLAINER_TYPE = "LimeImages" +DEFAULT_NUM_SAMPLES = "1000" +DEFAULT_SEGMENTATION_ALGORITHM = "quickshift" +DEFAULT_TOP_LABELS = "10" +DEFAULT_MIN_WEIGHT = "0.01" +DEFAULT_POSITIVE_ONLY = "true" +# The required parameter is predictor_host + +parser = argparse.ArgumentParser(parents=[kfserving.kfserver.parser]) +parser.add_argument('--model_name', default=DEFAULT_MODEL_NAME, + help='The name that the model is served under.') +parser.add_argument('--num_samples', default=DEFAULT_NUM_SAMPLES, + help='The number of samples the explainer is allowed to take.') +parser.add_argument('--segmentation_algorithm', default=DEFAULT_SEGMENTATION_ALGORITHM, + help='The algorithm used for segmentation.') +parser.add_argument('--top_labels', default=DEFAULT_TOP_LABELS, + help='The number of most likely classifications to return.') +parser.add_argument('--min_weight', default=DEFAULT_MIN_WEIGHT, + help='The minimum weight needed by a pixel to be considered useful as an explanation.') +parser.add_argument('--positive_only', default=DEFAULT_POSITIVE_ONLY, + help='Whether or not to show only the explanations that positively indicate a classification.') +parser.add_argument('--explainer_type', default=DEFAULT_EXPLAINER_TYPE, + help='What type of model explainer to use.') + +parser.add_argument('--predictor_host', help='The host for the predictor.', required=True) +args, _ = parser.parse_known_args() + +if __name__ == "__main__": + model = AIXModel(name=args.model_name, predictor_host=args.predictor_host, + segm_alg=args.segmentation_algorithm, num_samples=args.num_samples, + top_labels=args.top_labels, min_weight=args.min_weight, + positive_only=args.positive_only, explainer_type=args.explainer_type) + model.load() + kfserving.KFServer().start([model]) \ No newline at end of file diff --git a/python/aixexplainer/aixserver/model.py b/python/aixexplainer/aixserver/model.py new file mode 100644 index 0000000000..c83bad0349 --- /dev/null +++ b/python/aixexplainer/aixserver/model.py @@ -0,0 +1,87 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from typing import Dict + +import kfserving +import numpy as np +from aix360.algorithms.lime import LimeImageExplainer +from lime.wrappers.scikit_image import SegmentationAlgorithm + + +class AIXModel(kfserving.KFModel): # pylint:disable=c-extension-no-member + def __init__(self, name: str, predictor_host: str, segm_alg: str, num_samples: str, + top_labels: str, min_weight: str, positive_only: str, explainer_type: str): + super().__init__(name) + print("INIT") + self.name = name + self.top_labels = int(top_labels) + self.num_samples = int(num_samples) + self.segmentation_alg = segm_alg + self.predictor_host = predictor_host + self.min_weight = float(min_weight) + self.positive_only = (positive_only.lower() == "true") | (positive_only.lower() == "t") + if str.lower(explainer_type) != "limeimages": + raise Exception("Invalid explainer type: %s" % explainer_type) + self.explainer_type = explainer_type + self.ready = False + + def load(self): + print("LOADED") + self.ready = True + + def _predict(self, input_im): + input_im = np.array(input_im) + scoring_data = {'instances': input_im.tolist()} + + predictions = self.predict(scoring_data) + return predictions['predictions'] + + def explain(self, request: Dict) -> Dict: + print("Explaining now") + instances = request["instances"] + try: + inputs = np.array(instances[0]) + except Exception as err: + raise Exception( + "Failed to initialize NumPy array from inputs: %s, %s" % (err, instances)) + try: + if str.lower(self.explainer_type) == "limeimages": + explainer = LimeImageExplainer(verbose=False) + segmenter = SegmentationAlgorithm(self.segmentation_alg, kernel_size=1, + max_dist=200, ratio=0.2) + explanation = explainer.explain_instance(inputs, + classifier_fn=self._predict, + top_labels=self.top_labels, + hide_color=0, + num_samples=self.num_samples, + segmentation_fn=segmenter) + + temp = [] + masks = [] + for i in range(0, self.top_labels): + temp, mask = explanation.get_image_and_mask(explanation.top_labels[i], + positive_only=self.positive_only, + num_features=10, + hide_rest=False, + min_weight=self.min_weight) + masks.append(mask.tolist()) + + return {"explanations": { + "temp": temp.tolist(), + "masks": masks, + "top_labels": np.array(explanation.top_labels).astype(np.int32).tolist() + }} + + except Exception as err: + raise Exception("Failed to explain %s" % err) diff --git a/python/aixexplainer/setup.py b/python/aixexplainer/setup.py new file mode 100644 index 0000000000..0834f0a157 --- /dev/null +++ b/python/aixexplainer/setup.py @@ -0,0 +1,42 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from setuptools import setup, find_packages + +tests_require = [ + 'pytest', + 'pytest-tornasync', + 'mypy' +] +setup( + name='aixserver', + version='0.2.1', + author_email='Andrew.Butler@ibm.com', + license='https://github.com/kubeflow/kfserving/LICENSE', + url='https://github.com/kubeflow/kfserving/python/aixserver', + description='Model Server implementation for AI eXplainability with LIME. \ + Not intended for use outside KFServing Frameworks Images', + long_description=open('README.md').read(), + python_requires='>3.4', + packages=find_packages("aixserver"), + install_requires=[ + "kfserving>=0.2.1", + "argparse >= 1.4.0", + "numpy >= 1.8.2", + "aix360 >= 0.1.0", + "lime >= 0.1.1.37", + ], + tests_require=tests_require, + extras_require={'test': tests_require} +) \ No newline at end of file From 1b48186882821c726294058f71b359fb6b9f710c Mon Sep 17 00:00:00 2001 From: Andrew Butler Date: Tue, 1 Sep 2020 09:21:24 -0700 Subject: [PATCH 04/32] Fix link with local reference --- python/aixexplainer/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/aixexplainer/README.md b/python/aixexplainer/README.md index 5af8492fd3..9696021189 100644 --- a/python/aixexplainer/README.md +++ b/python/aixexplainer/README.md @@ -14,4 +14,4 @@ Once your docker image is pushed you can pull the image from `dockeruser/aixserv ## Example -Try deploying [LIME with MNIST](https://github.com/drewbutlerbb4/kfserving/tree/master/docs/samples/explanation/aix/mnist) +Try deploying [LIME with MNIST](../../docs/samples/explanation/aix/mnist) From b00d2dba23769f0eb3fb34ce39c5247cf81cacd4 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Wed, 2 Sep 2020 16:26:15 -0700 Subject: [PATCH 05/32] aix api patch --- config/configmap/inferenceservice.yaml | 5 +- ...erving.kubeflow.org_inferenceservices.yaml | 60 +++++-- .../development/configmap/ko_resolve_batcher | 2 +- docs/samples/explanation/aix/mnist/README.md | 9 +- .../explanation/aix/mnist/aix-explainer.yaml | 34 ++-- .../explanation/aix/mnist/query_explain.py | 11 +- pkg/apis/serving/v1alpha2/explainer_aix360.go | 13 +- .../serving/v1alpha2/explainer_aix360_test.go | 7 +- .../serving/v1alpha2/zz_generated.deepcopy.go | 1 - pkg/apis/serving/v1beta1/explainer.go | 2 + pkg/apis/serving/v1beta1/explainer_aix360.go | 81 +++++++++ .../serving/v1beta1/explainer_aix360_test.go | 168 ++++++++++++++++++ .../serving/v1beta1/zz_generated.deepcopy.go | 28 +++ 13 files changed, 357 insertions(+), 64 deletions(-) create mode 100644 pkg/apis/serving/v1beta1/explainer_aix360.go create mode 100644 pkg/apis/serving/v1beta1/explainer_aix360_test.go diff --git a/config/configmap/inferenceservice.yaml b/config/configmap/inferenceservice.yaml index 1f92434dd3..7637dae6b2 100644 --- a/config/configmap/inferenceservice.yaml +++ b/config/configmap/inferenceservice.yaml @@ -72,10 +72,7 @@ data: }, "aix": { "image" : "aipipeline/aix-explainer", - "defaultImageVersion": "0.2.2", - "allowedImageVersions": [ - "0.2.2" - ] + "defaultImageVersion": "0.2.2" } } storageInitializer: |- diff --git a/config/crd/serving.kubeflow.org_inferenceservices.yaml b/config/crd/serving.kubeflow.org_inferenceservices.yaml index ad3d37c9cc..27ba79f991 100644 --- a/config/crd/serving.kubeflow.org_inferenceservices.yaml +++ b/config/crd/serving.kubeflow.org_inferenceservices.yaml @@ -51,41 +51,35 @@ spec: explainer: properties: aix: - description: Spec for AIX explainer properties: config: additionalProperties: type: string - description: Inline custom parameter settings for explainer type: object resources: - description: Defaults to requests and limits of 1CPU, 2Gb - MEM. properties: limits: additionalProperties: - type: string - description: 'Limits describes the maximum amount of - compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/' + 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 type: object requests: additionalProperties: - type: string - 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-compute-resources-container/' + 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 type: object type: object runtimeVersion: - description: Defaults to latest AIX Version type: string storageUri: - description: The location of a trained explanation model type: string type: - description: The type of AIX explainer type: string required: - type @@ -2001,6 +1995,40 @@ spec: properties: explainer: properties: + aix: + properties: + config: + additionalProperties: + type: string + type: object + resources: + properties: + 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 + 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 + type: object + type: object + runtimeVersion: + type: string + storageUri: + type: string + type: + type: string + required: + - type + type: object alibi: properties: config: diff --git a/config/overlays/development/configmap/ko_resolve_batcher b/config/overlays/development/configmap/ko_resolve_batcher index 363c48b934..64f3052b9a 100644 --- a/config/overlays/development/configmap/ko_resolve_batcher +++ b/config/overlays/development/configmap/ko_resolve_batcher @@ -1 +1 @@ -image: github.com/kubeflow/kfserving/cmd/batcher +image: ko://github.com/kubeflow/kfserving/cmd/batcher diff --git a/docs/samples/explanation/aix/mnist/README.md b/docs/samples/explanation/aix/mnist/README.md index e4cc97e040..c185651d78 100644 --- a/docs/samples/explanation/aix/mnist/README.md +++ b/docs/samples/explanation/aix/mnist/README.md @@ -13,16 +13,19 @@ NAME URL READY DEFAULT T aixserver http://aixserver.somecluster/v1/models/aixserver True 100 40m ``` -Query the inferenceservice with the url and append `:explain` to signify the query is asking for an explanation. +## Prediction +The first step is to [determine the ingress IP and ports](../../../README.md#determine-the-ingress-ip-and-ports) and set `INGRESS_HOST` and `INGRESS_PORT` ``` -python query_explain.py http://aixserver.somecluster/v1/models/aixserver:explain +MODEL_NAME=aix-explainer +SERVICE_HOSTNAME=$(kubectl get inferenceservice ${MODEL_NAME} -o jsonpath='{.status.url}' | cut -d "/" -f 3) +python query_explain.py http://${INGRESS_HOST}:${INGRESS_PORT}/v1/models/$MODEL_NAME:explain ${SERVICE_HOSTNAME} ``` To try a different MNIST example add an integer to the end of the query between 0-10,000. The integer chosen will be the index of the image to be chosen in the MNIST dataset. ``` -python query_explain.py http://aixserver.somecluster/v1/models/aixserver:explain 100 +python query_explain.py http://${INGRESS_HOST}:${INGRESS_PORT}/v1/models/$MODEL_NAME:explain ${SERVICE_HOSTNAME} 100 ``` ## Deploying AIX explanations for another Image Classifier diff --git a/docs/samples/explanation/aix/mnist/aix-explainer.yaml b/docs/samples/explanation/aix/mnist/aix-explainer.yaml index 98203daba9..a6cc62b2ab 100644 --- a/docs/samples/explanation/aix/mnist/aix-explainer.yaml +++ b/docs/samples/explanation/aix/mnist/aix-explainer.yaml @@ -1,9 +1,8 @@ -apiVersion: serving.kubeflow.org/v1alpha2 -kind: InferenceService +apiVersion: "serving.kubeflow.org/v1alpha2" +kind: "InferenceService" metadata: - labels: - controller-tools.k8s.io: "1.0" - name: aixserver + name: "aix-explainer" + namespace: default spec: default: predictor: @@ -11,7 +10,7 @@ spec: container: name: predictor image: aipipeline/rf-predictor:0.2.2 - command: ["python", "-m", "rfserver", "--model_name", "aixserver"] + command: ["python", "-m", "rfserver", "--model_name", "aix-explainer"] imagePullPolicy: Always resources: requests: @@ -21,16 +20,13 @@ spec: memory: "2Gi" cpu: "1" explainer: - custom: - container: - name: explainer - image: aipipeline/aix-explainer:0.2.2 - command: ["python", "-m", "aixserver", "--predictor_host", "aixserver-predictor-default.default.svc.cluster.local", "explainer_type", "LimeImages"] - imagePullPolicy: Always - resources: - requests: - memory: "4Gi" - cpu: "2" - limits: - memory: "4Gi" - cpu: "2" + aix: + type: LimeImages + config: + num_samples: "100" + top_labels: "10" + min_weight: "0.01" + resources: + requests: + cpu: 0.1 + memory: 2Gi diff --git a/docs/samples/explanation/aix/mnist/query_explain.py b/docs/samples/explanation/aix/mnist/query_explain.py index 95fc1916d2..10c8437826 100644 --- a/docs/samples/explanation/aix/mnist/query_explain.py +++ b/docs/samples/explanation/aix/mnist/query_explain.py @@ -16,12 +16,15 @@ print('************************************************************') print("starting query") -if len(sys.argv) == 1: +if len(sys.argv) < 3: raise Exception("No endpoint specified. ") endpoint = sys.argv[1] +headers = { + 'Host': sys.argv[2] +} test_num = 1002 is_file = False -if len(sys.argv) > 2: +if len(sys.argv) > 3: try: test_num = int(sys.argv[2]) except: @@ -46,7 +49,7 @@ x = time.time() -res = requests.post(endpoint, json=input_image) +res = requests.post(endpoint, json=input_image, headers=headers) print("TIME TAKEN: ", time.time() - x) @@ -64,4 +67,4 @@ c_ax.imshow(label2rgb(mask, temp, bg_label = 0), interpolation = 'nearest') c_ax.set_title('Positive for {}\nActual {}'.format(top_labels[i], actual)) c_ax.axis('off') -plt.show() \ No newline at end of file +plt.show() diff --git a/pkg/apis/serving/v1alpha2/explainer_aix360.go b/pkg/apis/serving/v1alpha2/explainer_aix360.go index c80052819e..e7fd63f11e 100644 --- a/pkg/apis/serving/v1alpha2/explainer_aix360.go +++ b/pkg/apis/serving/v1alpha2/explainer_aix360.go @@ -1,20 +1,13 @@ package v1alpha2 import ( - "fmt" "sort" "strconv" - "strings" "github.com/kubeflow/kfserving/pkg/constants" - "github.com/kubeflow/kfserving/pkg/utils" v1 "k8s.io/api/core/v1" ) -var ( - InvalidAIXRuntimeVersionError = "AIX RuntimeVersion must be one of %s" -) - func (s *AIXExplainerSpec) GetStorageUri() string { return s.StorageURI } @@ -66,9 +59,5 @@ func (s *AIXExplainerSpec) ApplyDefaults(config *InferenceServicesConfig) { } func (s *AIXExplainerSpec) Validate(config *InferenceServicesConfig) error { - if !utils.Includes(config.Explainers.AIXExplainer.AllowedImageVersions, s.RuntimeVersion) { - return fmt.Errorf(InvalidAIXRuntimeVersionError, strings.Join(config.Explainers.AIXExplainer.AllowedImageVersions, ", ")) - } - return nil -} \ No newline at end of file +} diff --git a/pkg/apis/serving/v1alpha2/explainer_aix360_test.go b/pkg/apis/serving/v1alpha2/explainer_aix360_test.go index b5a627ea57..08fbeef1e8 100644 --- a/pkg/apis/serving/v1alpha2/explainer_aix360_test.go +++ b/pkg/apis/serving/v1alpha2/explainer_aix360_test.go @@ -41,9 +41,8 @@ func TestAIXExplainer(t *testing.T) { config := &InferenceServicesConfig{ Explainers: &ExplainersConfig{ AIXExplainer: ExplainerConfig{ - ContainerImage: "aipipeline/aixexplainer", - DefaultImageVersion: "latest", - AllowedImageVersions: allowedAIXImageVersionsArray, + ContainerImage: "aipipeline/aixexplainer", + DefaultImageVersion: "latest", }, }, } @@ -166,4 +165,4 @@ func TestCreateAIXExplainerContainerWithConfig(t *testing.T) { // Test Create with config container := spec.CreateExplainerContainer("someName", 0, "predictor.svc.cluster.local", config) g.Expect(container).To(gomega.Equal(expectedContainer)) -} \ No newline at end of file +} diff --git a/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go b/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go index 8a68b618ba..3121d7b2ac 100644 --- a/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go +++ b/pkg/apis/serving/v1alpha2/zz_generated.deepcopy.go @@ -37,7 +37,6 @@ func (in *AIXExplainerSpec) DeepCopyInto(out *AIXExplainerSpec) { (*out)[key] = val } } - return } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AIXExplainerSpec. diff --git a/pkg/apis/serving/v1beta1/explainer.go b/pkg/apis/serving/v1beta1/explainer.go index ef36fa0993..308fa6bb13 100644 --- a/pkg/apis/serving/v1beta1/explainer.go +++ b/pkg/apis/serving/v1beta1/explainer.go @@ -21,6 +21,8 @@ package v1beta1 type ExplainerSpec struct { // Spec for alibi explainer Alibi *AlibiExplainerSpec `json:"alibi,omitempty"` + // Spec for AIX explainer + AIX *AIXExplainerSpec `json:"aix,omitempty"` // Pass through Pod fields or specify a custom container spec *CustomExplainer `json:",inline"` // Extensions available in all components diff --git a/pkg/apis/serving/v1beta1/explainer_aix360.go b/pkg/apis/serving/v1beta1/explainer_aix360.go new file mode 100644 index 0000000000..7164c2efb3 --- /dev/null +++ b/pkg/apis/serving/v1beta1/explainer_aix360.go @@ -0,0 +1,81 @@ +package v1beta1 + +import ( + "sort" + "strconv" + + "github.com/golang/protobuf/proto" + "github.com/kubeflow/kfserving/pkg/constants" + v1 "k8s.io/api/core/v1" +) + +type AIXExplainerType string + +const ( + AIXLimeImageExplainer AIXExplainerType = "LimeImages" +) + +// AIXExplainerSpec defines the arguments for configuring an AIX Explanation Server +type AIXExplainerSpec struct { + // The type of AIX explainer + Type AIXExplainerType `json:"type"` + // The location of a trained explanation model + StorageURI string `json:"storageUri,omitempty"` + // Defaults to latest AIX Version + RuntimeVersion string `json:"runtimeVersion,omitempty"` + // Defaults to requests and limits of 1CPU, 2Gb MEM. + Resources v1.ResourceRequirements `json:"resources,omitempty"` + // Inline custom parameter settings for explainer + Config map[string]string `json:"config,omitempty"` +} + +func (s *AIXExplainerSpec) GetStorageUri() string { + return s.StorageURI +} + +func (s *AIXExplainerSpec) GetResourceRequirements() *v1.ResourceRequirements { + // return the ResourceRequirements value if set on the spec + return &s.Resources +} + +func (s *AIXExplainerSpec) CreateExplainerContainer(modelName string, parallelism int, predictorHost string, config *InferenceServicesConfig) *v1.Container { + var args = []string{ + constants.ArgumentModelName, modelName, + constants.ArgumentPredictorHost, predictorHost, + constants.ArgumentHttpPort, constants.InferenceServiceDefaultHttpPort, + } + if parallelism != 0 { + args = append(args, constants.ArgumentWorkers, strconv.Itoa(parallelism)) + } + if s.StorageURI != "" { + args = append(args, "--storage_uri", constants.DefaultModelLocalMountPath) + } + + args = append(args, "--explainer_type", string(s.Type)) + + // Order explainer config map keys + var keys []string + for k, _ := range s.Config { + keys = append(keys, k) + } + sort.Strings(keys) + for _, k := range keys { + args = append(args, "--"+k) + args = append(args, s.Config[k]) + } + + return &v1.Container{ + Image: config.Explainers.AIXExplainer.ContainerImage + ":" + s.RuntimeVersion, + Name: constants.InferenceServiceContainerName, + Resources: s.Resources, + Args: args, + } +} + +func (s *AIXExplainerSpec) Default(config *InferenceServicesConfig) { + s.Name = constants.InferenceServiceContainerName + if s.RuntimeVersion == nil { + s.RuntimeVersion = proto.String(config.Explainers.AIXExplainer.DefaultImageVersion) + } + setResourceRequirementDefaults(&s.Resources) +} diff --git a/pkg/apis/serving/v1beta1/explainer_aix360_test.go b/pkg/apis/serving/v1beta1/explainer_aix360_test.go new file mode 100644 index 0000000000..705b0f278d --- /dev/null +++ b/pkg/apis/serving/v1beta1/explainer_aix360_test.go @@ -0,0 +1,168 @@ +package v1beta1 + +import ( + "fmt" + "strings" + "testing" + + "github.com/kubeflow/kfserving/pkg/constants" + "github.com/onsi/gomega" + "github.com/onsi/gomega/types" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/api/resource" +) + +func TestAIXExplainer(t *testing.T) { + g := gomega.NewGomegaWithT(t) + allowedAIXImageVersionsArray := []string{ + DefaultAIXExplainerRuntimeVersion, + } + allowedAIXImageVersions := strings.Join(allowedAIXImageVersionsArray, ", ") + + scenarios := map[string]struct { + spec AIXExplainerSpec + matcher types.GomegaMatcher + }{ + "AcceptGoodRuntimeVersion": { + spec: AIXExplainerSpec{ + RuntimeVersion: DefaultAIXExplainerRuntimeVersion, + }, + matcher: gomega.Succeed(), + }, + "RejectBadRuntimeVersion": { + spec: AIXExplainerSpec{ + RuntimeVersion: "", + }, + matcher: gomega.MatchError(fmt.Sprintf(InvalidAIXRuntimeVersionError, allowedAIXImageVersions)), + }, + } + + for name, scenario := range scenarios { + config := &InferenceServicesConfig{ + Explainers: &ExplainersConfig{ + AIXExplainer: ExplainerConfig{ + ContainerImage: "aipipeline/aixexplainer", + DefaultImageVersion: "latest", + }, + }, + } + g.Expect(scenario.spec.Validate(config)).Should(scenario.matcher, fmt.Sprintf("Testing %s", name)) + } +} + +func TestCreateAIXExplainerContainer(t *testing.T) { + + var requestedResource = v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "cpu": resource.Quantity{ + Format: "100", + }, + }, + Requests: v1.ResourceList{ + "cpu": resource.Quantity{ + Format: "90", + }, + }, + } + config := &InferenceServicesConfig{ + Explainers: &ExplainersConfig{ + AIXExplainer: ExplainerConfig{ + ContainerImage: "aipipeline/aixexplainer", + DefaultImageVersion: "latest", + }, + }, + } + var spec = AIXExplainerSpec{ + Type: "LimeImages", + StorageURI: "gs://someUri", + Resources: requestedResource, + RuntimeVersion: "0.2.2", + } + g := gomega.NewGomegaWithT(t) + + expectedContainer := &v1.Container{ + Image: "aipipeline/aixexplainer:0.2.2", + Name: constants.InferenceServiceContainerName, + Resources: requestedResource, + Args: []string{ + constants.ArgumentModelName, + "someName", + constants.ArgumentPredictorHost, + "predictor.svc.cluster.local", + constants.ArgumentHttpPort, + constants.InferenceServiceDefaultHttpPort, + "--storage_uri", + "/mnt/models", + "--explainer_type", + "LimeImages", + }, + } + + // Test Create with config + container := spec.CreateExplainerContainer("someName", 0, "predictor.svc.cluster.local", config) + g.Expect(container).To(gomega.Equal(expectedContainer)) +} + +func TestCreateAIXExplainerContainerWithConfig(t *testing.T) { + + var requestedResource = v1.ResourceRequirements{ + Limits: v1.ResourceList{ + "cpu": resource.Quantity{ + Format: "100", + }, + }, + Requests: v1.ResourceList{ + "cpu": resource.Quantity{ + Format: "90", + }, + }, + } + config := &InferenceServicesConfig{ + Explainers: &ExplainersConfig{ + AIXExplainer: ExplainerConfig{ + ContainerImage: "aipipeline/aixexplainer", + DefaultImageVersion: "latest", + }, + }, + } + var spec = AIXExplainerSpec{ + Type: "LimeImages", + StorageURI: "gs://someUri", + Resources: requestedResource, + RuntimeVersion: "0.2.2", + Config: map[string]string{ + "num_classes": "10", + "num_samples": "20", + "min_weight": "0", + }, + } + g := gomega.NewGomegaWithT(t) + + expectedContainer := &v1.Container{ + Image: "aipipeline/aixexplainer:0.2.2", + Name: constants.InferenceServiceContainerName, + Resources: requestedResource, + Args: []string{ + "--model_name", + "someName", + "--predictor_host", + "predictor.svc.cluster.local", + "--http_port", + "8080", + "--storage_uri", + "/mnt/models", + "--explainer_type", + "LimeImages", + "--min_weight", + "0", + "--num_classes", + "10", + "--num_samples", + "20", + }, + } + + // Test Create with config + container := spec.CreateExplainerContainer("someName", 0, "predictor.svc.cluster.local", config) + g.Expect(container).To(gomega.Equal(expectedContainer)) +} diff --git a/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go b/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go index e72508c225..ec904caec3 100644 --- a/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go +++ b/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go @@ -25,6 +25,29 @@ import ( "knative.dev/pkg/apis/duck/v1" ) +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *AIXExplainerSpec) DeepCopyInto(out *AIXExplainerSpec) { + *out = *in + in.Resources.DeepCopyInto(&out.Resources) + if in.Config != nil { + in, out := &in.Config, &out.Config + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AIXExplainerSpec. +func (in *AIXExplainerSpec) DeepCopy() *AIXExplainerSpec { + if in == nil { + return nil + } + out := new(AIXExplainerSpec) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *AlibiExplainerSpec) DeepCopyInto(out *AlibiExplainerSpec) { *out = *in @@ -204,6 +227,11 @@ func (in *ExplainerSpec) DeepCopyInto(out *ExplainerSpec) { *out = new(AlibiExplainerSpec) (*in).DeepCopyInto(*out) } + if in.AIX != nil { + in, out := &in.AIX, &out.AIX + *out = new(AIXExplainerSpec) + (*in).DeepCopyInto(*out) + } if in.CustomExplainer != nil { in, out := &in.CustomExplainer, &out.CustomExplainer *out = new(CustomExplainer) From 0684791f72e9907d48615186b399e16eeeaec344 Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Fri, 4 Sep 2020 10:44:17 -0700 Subject: [PATCH 06/32] Add random forest predictor --- .../explanation/aix/mnist/rf.Dockerfile | 6 ++ .../explanation/aix/mnist/rfserver/README.md | 1 + .../aix/mnist/rfserver/rfmodel.pickle | Bin 0 -> 731158 bytes .../aix/mnist/rfserver/rfserver/__init__.py | 15 ++++ .../aix/mnist/rfserver/rfserver/__main__.py | 31 +++++++ .../aix/mnist/rfserver/rfserver/model.py | 78 ++++++++++++++++++ .../explanation/aix/mnist/rfserver/setup.py | 42 ++++++++++ 7 files changed, 173 insertions(+) create mode 100644 docs/samples/explanation/aix/mnist/rf.Dockerfile create mode 100644 docs/samples/explanation/aix/mnist/rfserver/README.md create mode 100644 docs/samples/explanation/aix/mnist/rfserver/rfmodel.pickle create mode 100644 docs/samples/explanation/aix/mnist/rfserver/rfserver/__init__.py create mode 100644 docs/samples/explanation/aix/mnist/rfserver/rfserver/__main__.py create mode 100644 docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py create mode 100644 docs/samples/explanation/aix/mnist/rfserver/setup.py diff --git a/docs/samples/explanation/aix/mnist/rf.Dockerfile b/docs/samples/explanation/aix/mnist/rf.Dockerfile new file mode 100644 index 0000000000..83dbeaeb2d --- /dev/null +++ b/docs/samples/explanation/aix/mnist/rf.Dockerfile @@ -0,0 +1,6 @@ +FROM python:3.7 + +COPY . . +RUN pip install --upgrade pip && pip install -e ./kfserving +RUN pip install -e ./rfserver +ENTRYPOINT ["python", "-m", "rfserver", "--model_name", "aixserver"] \ No newline at end of file diff --git a/docs/samples/explanation/aix/mnist/rfserver/README.md b/docs/samples/explanation/aix/mnist/rfserver/README.md new file mode 100644 index 0000000000..896cfc81c2 --- /dev/null +++ b/docs/samples/explanation/aix/mnist/rfserver/README.md @@ -0,0 +1 @@ +# Random Forest for MNIST on kfserving \ No newline at end of file diff --git a/docs/samples/explanation/aix/mnist/rfserver/rfmodel.pickle b/docs/samples/explanation/aix/mnist/rfserver/rfmodel.pickle new file mode 100644 index 0000000000000000000000000000000000000000..244e7d22a4fb8b1dc2d1f7f08ae0eb46898fdbe7 GIT binary patch literal 731158 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 literal 0 HcmV?d00001 diff --git a/docs/samples/explanation/aix/mnist/rfserver/rfserver/__init__.py b/docs/samples/explanation/aix/mnist/rfserver/rfserver/__init__.py new file mode 100644 index 0000000000..e5c00234ff --- /dev/null +++ b/docs/samples/explanation/aix/mnist/rfserver/rfserver/__init__.py @@ -0,0 +1,15 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .model import RFModel \ No newline at end of file diff --git a/docs/samples/explanation/aix/mnist/rfserver/rfserver/__main__.py b/docs/samples/explanation/aix/mnist/rfserver/rfserver/__main__.py new file mode 100644 index 0000000000..5ed38c9a5d --- /dev/null +++ b/docs/samples/explanation/aix/mnist/rfserver/rfserver/__main__.py @@ -0,0 +1,31 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import kfserving +import argparse +import os + +from .model import RFModel + +DEFAULT_MODEL_NAME = "rfserver" + +parser = argparse.ArgumentParser(parents=[kfserving.kfserver.parser]) +parser.add_argument('--model_name', default=DEFAULT_MODEL_NAME, + help='The name that the model is served under.') +args, _ = parser.parse_known_args() + +if __name__ == "__main__": + model = RFModel(args.model_name) + model.load() + kfserving.KFServer().start([model]) \ No newline at end of file diff --git a/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py b/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py new file mode 100644 index 0000000000..b1ff82b1df --- /dev/null +++ b/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py @@ -0,0 +1,78 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from typing import Dict +import pickle + +import kfserving +import numpy as np + +from sklearn.pipeline import Pipeline +from sklearn.ensemble import RandomForestClassifier +from sklearn.preprocessing import Normalizer +from skimage.color import gray2rgb # since the code wants color images + +class PipeStep(object): + """ + Wrapper for turning functions into pipeline transforms (no-fitting) + """ + def __init__(self, step_func): + self._step_func=step_func + def fit(self,*args): + return self + def transform(self,X): + return self._step_func(X) + +class RFModel(kfserving.KFModel): #pylint:disable=c-extension-no-member + def __init__(self, name: str): + super().__init__(name) + print("INIT") + self.name = name + self.ready = False + + def load(self): + + with open('/rfserver/rfmodel.pickle', 'rb') as f: + rf = pickle.load(f) + self.model = rf + + print("LOADED") + self.ready = True + + def predict(self, request: Dict) -> Dict: + print("Prediction requested") + instances = request["instances"] + + try: + inputs = np.asarray(instances) + except Exception as e: + raise Exception( + "Failed to initialize NumPy array from inputs: %s, %s" % (e, instances)) + + try: + + n_samples, a, b, c = inputs.shape + inputs = np.reshape(inputs, (n_samples, 2352)) + + predictions = self.model.predict_proba(inputs) + + class_preds = [[] for x in range(0, len(predictions[0]))] + for j in range(0, len(predictions[0])): + for i in range(0, len(predictions)): + class_preds[j].append(predictions[i][j][1]) + + return {"predictions" : class_preds} + except Exception as e: + raise Exception("Failed to predict %s" % e) \ No newline at end of file diff --git a/docs/samples/explanation/aix/mnist/rfserver/setup.py b/docs/samples/explanation/aix/mnist/rfserver/setup.py new file mode 100644 index 0000000000..8906076b70 --- /dev/null +++ b/docs/samples/explanation/aix/mnist/rfserver/setup.py @@ -0,0 +1,42 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from setuptools import setup, find_packages + +tests_require = [ + 'pytest', + 'pytest-tornasync', + 'mypy' +] +setup( + name='rfserver', + version='0.2.1', + author_email='Andrew.Butler@ibm.com', + license='https://github.com/kubeflow/kfserving/LICENSE', + url='https://github.com/kubeflow/kfserving/python/rfserver', + description='Model Server implementation for AI eXplainability using LIME. \ + Not intended for use outside KFServing Frameworks Images', + long_description=open('README.md').read(), + python_requires='>3.4', + packages=find_packages("rfserver"), + install_requires=[ + "kfserving>=0.2.1", + "argparse >= 1.4.0", + "numpy >= 1.8.2", + "scikit-learn >= 0.0", + "scikit-image >= 0.0", + ], + tests_require=tests_require, + extras_require={'test': tests_require} +) From 071d7e55857940bafaed94c506573eb37ff849c0 Mon Sep 17 00:00:00 2001 From: Andrew Butler Date: Wed, 9 Sep 2020 10:45:29 -0700 Subject: [PATCH 07/32] Fix link --- docs/samples/explanation/aix/mnist/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/samples/explanation/aix/mnist/README.md b/docs/samples/explanation/aix/mnist/README.md index c185651d78..c9a48cc7fd 100644 --- a/docs/samples/explanation/aix/mnist/README.md +++ b/docs/samples/explanation/aix/mnist/README.md @@ -14,7 +14,7 @@ aixserver http://aixserver.somecluster/v1/models/aixserver True 100 ``` ## Prediction -The first step is to [determine the ingress IP and ports](../../../README.md#determine-the-ingress-ip-and-ports) and set `INGRESS_HOST` and `INGRESS_PORT` +The first step is to [determine the ingress IP and ports](../../../../../README.md#determine-the-ingress-ip-and-ports) and set `INGRESS_HOST` and `INGRESS_PORT` ``` MODEL_NAME=aix-explainer From b3ed924687a10f5f9274bb38eb96f654aabecc61 Mon Sep 17 00:00:00 2001 From: Andrew Butler Date: Wed, 9 Sep 2020 13:31:32 -0700 Subject: [PATCH 08/32] Update aix-explainer image version --- config/configmap/inferenceservice.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/configmap/inferenceservice.yaml b/config/configmap/inferenceservice.yaml index 7637dae6b2..56636da7a9 100644 --- a/config/configmap/inferenceservice.yaml +++ b/config/configmap/inferenceservice.yaml @@ -72,7 +72,7 @@ data: }, "aix": { "image" : "aipipeline/aix-explainer", - "defaultImageVersion": "0.2.2" + "defaultImageVersion": "0.4" } } storageInitializer: |- From a40fe6f9631f8ebce26259f4eda285fdbfe6a131 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Wed, 9 Sep 2020 15:21:45 -0700 Subject: [PATCH 09/32] Clean up example readme --- docs/samples/explanation/aix/mnist/README.md | 28 ++------------------ 1 file changed, 2 insertions(+), 26 deletions(-) diff --git a/docs/samples/explanation/aix/mnist/README.md b/docs/samples/explanation/aix/mnist/README.md index c9a48cc7fd..f15ea1924b 100644 --- a/docs/samples/explanation/aix/mnist/README.md +++ b/docs/samples/explanation/aix/mnist/README.md @@ -1,5 +1,7 @@ # Using AIX to get explanations for MNIST classifications +This is an example of how to explain model outputs using [AIX360](https://github.com/Trusted-AI/AIX360) on KFServing. We will be using mnist, a dataset for handwritten digits, for this model and explain how the model decides the predicted results. + To deploy the inferenceservice `kubectl apply -f aix-explainer.yaml` @@ -28,32 +30,6 @@ To try a different MNIST example add an integer to the end of the query between python query_explain.py http://${INGRESS_HOST}:${INGRESS_PORT}/v1/models/$MODEL_NAME:explain ${SERVICE_HOSTNAME} 100 ``` -## Deploying AIX explanations for another Image Classifier - -This section is for users who have another Image classifier which you would like to get explanations for. Change the image from `aipipeline/aix-explainer:0.2.2` to the endpoint of your image in aix-explainer.yaml. - -``` -name: predictor -image: -``` - -Then deploy your inferenceservice. - -`kubectl apply -f aix-explainer.yaml` - -## Deploying a Development Explainer Image - -To deploy a development image go to `aix-explainer.yaml` and change the original explainer image to the endpoint of your image. - -``` -name: explainer -image: -``` - -Then deploy your inferenceservice. - -`kubectl apply -f aix-explainer.yaml` - ## Stopping the Inference Service `kubectl delete -f aix-explainer.yaml` From 7d270b68a5a9ed180fe052b1aff631a2e8516893 Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Thu, 10 Sep 2020 09:13:23 -0700 Subject: [PATCH 10/32] Refactor rfserver and update image --- docs/samples/explanation/aix/mnist/aix-explainer.yaml | 4 ++-- .../explanation/aix/mnist/{ => rfserver}/rf.Dockerfile | 4 ++-- docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) rename docs/samples/explanation/aix/mnist/{ => rfserver}/rf.Dockerfile (51%) diff --git a/docs/samples/explanation/aix/mnist/aix-explainer.yaml b/docs/samples/explanation/aix/mnist/aix-explainer.yaml index a6cc62b2ab..83f8d08b15 100644 --- a/docs/samples/explanation/aix/mnist/aix-explainer.yaml +++ b/docs/samples/explanation/aix/mnist/aix-explainer.yaml @@ -9,7 +9,7 @@ spec: custom: container: name: predictor - image: aipipeline/rf-predictor:0.2.2 + image: aipipeline/rf-predictor:0.4 command: ["python", "-m", "rfserver", "--model_name", "aix-explainer"] imagePullPolicy: Always resources: @@ -28,5 +28,5 @@ spec: min_weight: "0.01" resources: requests: - cpu: 0.1 + cpu: 1 memory: 2Gi diff --git a/docs/samples/explanation/aix/mnist/rf.Dockerfile b/docs/samples/explanation/aix/mnist/rfserver/rf.Dockerfile similarity index 51% rename from docs/samples/explanation/aix/mnist/rf.Dockerfile rename to docs/samples/explanation/aix/mnist/rfserver/rf.Dockerfile index 83dbeaeb2d..f978f55853 100644 --- a/docs/samples/explanation/aix/mnist/rf.Dockerfile +++ b/docs/samples/explanation/aix/mnist/rfserver/rf.Dockerfile @@ -1,6 +1,6 @@ FROM python:3.7 COPY . . -RUN pip install --upgrade pip && pip install -e ./kfserving -RUN pip install -e ./rfserver +RUN pip install --upgrade pip && pip install kfserving==0.4.0 +RUN pip install -e . ENTRYPOINT ["python", "-m", "rfserver", "--model_name", "aixserver"] \ No newline at end of file diff --git a/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py b/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py index b1ff82b1df..3ca663f3fe 100644 --- a/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py +++ b/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py @@ -44,7 +44,7 @@ def __init__(self, name: str): def load(self): - with open('/rfserver/rfmodel.pickle', 'rb') as f: + with open('../rfmodel.pickle', 'rb') as f: rf = pickle.load(f) self.model = rf From 48612e3d7a67475e79bfd4f7c93b67291671b924 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Thu, 10 Sep 2020 14:41:18 -0700 Subject: [PATCH 11/32] Update inferenceservice.yaml --- config/configmap/inferenceservice.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/configmap/inferenceservice.yaml b/config/configmap/inferenceservice.yaml index 56636da7a9..9b4712effe 100644 --- a/config/configmap/inferenceservice.yaml +++ b/config/configmap/inferenceservice.yaml @@ -72,7 +72,7 @@ data: }, "aix": { "image" : "aipipeline/aix-explainer", - "defaultImageVersion": "0.4" + "defaultImageVersion": "0.4.0" } } storageInitializer: |- From 64fd2546dca72971224ee7e51ac6efbbeca01e3d Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Thu, 10 Sep 2020 14:42:50 -0700 Subject: [PATCH 12/32] Update aix-explainer.yaml --- docs/samples/explanation/aix/mnist/aix-explainer.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/samples/explanation/aix/mnist/aix-explainer.yaml b/docs/samples/explanation/aix/mnist/aix-explainer.yaml index 83f8d08b15..508af298dd 100644 --- a/docs/samples/explanation/aix/mnist/aix-explainer.yaml +++ b/docs/samples/explanation/aix/mnist/aix-explainer.yaml @@ -9,7 +9,7 @@ spec: custom: container: name: predictor - image: aipipeline/rf-predictor:0.4 + image: aipipeline/rf-predictor:0.4.0 command: ["python", "-m", "rfserver", "--model_name", "aix-explainer"] imagePullPolicy: Always resources: From fa97fb22fe94af1ee7900d85daaa4ec00a2db8d1 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Thu, 10 Sep 2020 17:42:05 -0700 Subject: [PATCH 13/32] update v1beta1 spec and tests --- .../serving/v1alpha2/explainer_aix360_test.go | 11 ---- pkg/apis/serving/v1beta1/configmap.go | 2 + pkg/apis/serving/v1beta1/explainer_aix360.go | 22 +++++-- .../serving/v1beta1/explainer_aix360_test.go | 62 +++++++++---------- .../serving/v1beta1/zz_generated.deepcopy.go | 7 ++- 5 files changed, 54 insertions(+), 50 deletions(-) diff --git a/pkg/apis/serving/v1alpha2/explainer_aix360_test.go b/pkg/apis/serving/v1alpha2/explainer_aix360_test.go index 08fbeef1e8..54133b7c09 100644 --- a/pkg/apis/serving/v1alpha2/explainer_aix360_test.go +++ b/pkg/apis/serving/v1alpha2/explainer_aix360_test.go @@ -2,7 +2,6 @@ package v1alpha2 import ( "fmt" - "strings" "testing" "github.com/kubeflow/kfserving/pkg/constants" @@ -14,10 +13,6 @@ import ( func TestAIXExplainer(t *testing.T) { g := gomega.NewGomegaWithT(t) - allowedAIXImageVersionsArray := []string{ - DefaultAIXExplainerRuntimeVersion, - } - allowedAIXImageVersions := strings.Join(allowedAIXImageVersionsArray, ", ") scenarios := map[string]struct { spec AIXExplainerSpec @@ -29,12 +24,6 @@ func TestAIXExplainer(t *testing.T) { }, matcher: gomega.Succeed(), }, - "RejectBadRuntimeVersion": { - spec: AIXExplainerSpec{ - RuntimeVersion: "", - }, - matcher: gomega.MatchError(fmt.Sprintf(InvalidAIXRuntimeVersionError, allowedAIXImageVersions)), - }, } for name, scenario := range scenarios { diff --git a/pkg/apis/serving/v1beta1/configmap.go b/pkg/apis/serving/v1beta1/configmap.go index 3333ac275b..e8e2d48be0 100644 --- a/pkg/apis/serving/v1beta1/configmap.go +++ b/pkg/apis/serving/v1beta1/configmap.go @@ -20,6 +20,7 @@ import ( "context" "encoding/json" "fmt" + "sigs.k8s.io/controller-runtime/pkg/client/config" "github.com/kubeflow/kfserving/pkg/constants" @@ -46,6 +47,7 @@ type ExplainerConfig struct { // +kubebuilder:object:generate=false type ExplainersConfig struct { AlibiExplainer ExplainerConfig `json:"alibi,omitempty"` + AIXExplainer ExplainerConfig `json:"aix,omitempty"` } // +kubebuilder:object:generate=false diff --git a/pkg/apis/serving/v1beta1/explainer_aix360.go b/pkg/apis/serving/v1beta1/explainer_aix360.go index 7164c2efb3..689037b026 100644 --- a/pkg/apis/serving/v1beta1/explainer_aix360.go +++ b/pkg/apis/serving/v1beta1/explainer_aix360.go @@ -6,6 +6,7 @@ import ( "github.com/golang/protobuf/proto" "github.com/kubeflow/kfserving/pkg/constants" + "github.com/kubeflow/kfserving/pkg/utils" v1 "k8s.io/api/core/v1" ) @@ -22,15 +23,17 @@ type AIXExplainerSpec struct { // The location of a trained explanation model StorageURI string `json:"storageUri,omitempty"` // Defaults to latest AIX Version - RuntimeVersion string `json:"runtimeVersion,omitempty"` - // Defaults to requests and limits of 1CPU, 2Gb MEM. - Resources v1.ResourceRequirements `json:"resources,omitempty"` + RuntimeVersion *string `json:"runtimeVersion,omitempty"` + // Container enables overrides for the predictor. + // Each framework will have different defaults that are populated in the underlying container spec. + // +optional + v1.Container `json:",inline"` // Inline custom parameter settings for explainer Config map[string]string `json:"config,omitempty"` } -func (s *AIXExplainerSpec) GetStorageUri() string { - return s.StorageURI +func (s *AIXExplainerSpec) GetStorageUri() *string { + return &s.StorageURI } func (s *AIXExplainerSpec) GetResourceRequirements() *v1.ResourceRequirements { @@ -65,7 +68,7 @@ func (s *AIXExplainerSpec) CreateExplainerContainer(modelName string, parallelis } return &v1.Container{ - Image: config.Explainers.AIXExplainer.ContainerImage + ":" + s.RuntimeVersion, + Image: config.Explainers.AIXExplainer.ContainerImage + ":" + *s.RuntimeVersion, Name: constants.InferenceServiceContainerName, Resources: s.Resources, Args: args, @@ -79,3 +82,10 @@ func (s *AIXExplainerSpec) Default(config *InferenceServicesConfig) { } setResourceRequirementDefaults(&s.Resources) } + +// Validate the spec +func (s *AIXExplainerSpec) Validate() error { + return utils.FirstNonNilError([]error{ + validateStorageURI(s.GetStorageUri()), + }) +} diff --git a/pkg/apis/serving/v1beta1/explainer_aix360_test.go b/pkg/apis/serving/v1beta1/explainer_aix360_test.go index 705b0f278d..6a6b279025 100644 --- a/pkg/apis/serving/v1beta1/explainer_aix360_test.go +++ b/pkg/apis/serving/v1beta1/explainer_aix360_test.go @@ -1,10 +1,9 @@ package v1beta1 import ( - "fmt" - "strings" "testing" + "github.com/golang/protobuf/proto" "github.com/kubeflow/kfserving/pkg/constants" "github.com/onsi/gomega" "github.com/onsi/gomega/types" @@ -14,10 +13,14 @@ import ( func TestAIXExplainer(t *testing.T) { g := gomega.NewGomegaWithT(t) - allowedAIXImageVersionsArray := []string{ - DefaultAIXExplainerRuntimeVersion, + config := InferenceServicesConfig{ + Explainers: ExplainersConfig{ + AIXExplainer: ExplainerConfig{ + ContainerImage: "aipipeline/aixexplainer", + DefaultImageVersion: "latest", + }, + }, } - allowedAIXImageVersions := strings.Join(allowedAIXImageVersionsArray, ", ") scenarios := map[string]struct { spec AIXExplainerSpec @@ -25,28 +28,19 @@ func TestAIXExplainer(t *testing.T) { }{ "AcceptGoodRuntimeVersion": { spec: AIXExplainerSpec{ - RuntimeVersion: DefaultAIXExplainerRuntimeVersion, + RuntimeVersion: proto.String("latest"), }, matcher: gomega.Succeed(), }, - "RejectBadRuntimeVersion": { - spec: AIXExplainerSpec{ - RuntimeVersion: "", - }, - matcher: gomega.MatchError(fmt.Sprintf(InvalidAIXRuntimeVersionError, allowedAIXImageVersions)), - }, } - for name, scenario := range scenarios { - config := &InferenceServicesConfig{ - Explainers: &ExplainersConfig{ - AIXExplainer: ExplainerConfig{ - ContainerImage: "aipipeline/aixexplainer", - DefaultImageVersion: "latest", - }, - }, - } - g.Expect(scenario.spec.Validate(config)).Should(scenario.matcher, fmt.Sprintf("Testing %s", name)) + t.Run(name, func(t *testing.T) { + scenario.spec.Default(&config) + res := scenario.spec.Validate() + if !g.Expect(res).To(scenario.matcher) { + t.Errorf("got %q, want %q", res, scenario.matcher) + } + }) } } @@ -65,7 +59,7 @@ func TestCreateAIXExplainerContainer(t *testing.T) { }, } config := &InferenceServicesConfig{ - Explainers: &ExplainersConfig{ + Explainers: ExplainersConfig{ AIXExplainer: ExplainerConfig{ ContainerImage: "aipipeline/aixexplainer", DefaultImageVersion: "latest", @@ -73,10 +67,12 @@ func TestCreateAIXExplainerContainer(t *testing.T) { }, } var spec = AIXExplainerSpec{ - Type: "LimeImages", - StorageURI: "gs://someUri", - Resources: requestedResource, - RuntimeVersion: "0.2.2", + Type: "LimeImages", + StorageURI: "gs://someUri", + Container: v1.Container{ + Resources: requestedResource, + }, + RuntimeVersion: proto.String("0.2.2"), } g := gomega.NewGomegaWithT(t) @@ -118,7 +114,7 @@ func TestCreateAIXExplainerContainerWithConfig(t *testing.T) { }, } config := &InferenceServicesConfig{ - Explainers: &ExplainersConfig{ + Explainers: ExplainersConfig{ AIXExplainer: ExplainerConfig{ ContainerImage: "aipipeline/aixexplainer", DefaultImageVersion: "latest", @@ -126,10 +122,12 @@ func TestCreateAIXExplainerContainerWithConfig(t *testing.T) { }, } var spec = AIXExplainerSpec{ - Type: "LimeImages", - StorageURI: "gs://someUri", - Resources: requestedResource, - RuntimeVersion: "0.2.2", + Type: "LimeImages", + StorageURI: "gs://someUri", + Container: v1.Container{ + Resources: requestedResource, + }, + RuntimeVersion: proto.String("0.2.2"), Config: map[string]string{ "num_classes": "10", "num_samples": "20", diff --git a/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go b/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go index 5a4cac469c..709f551394 100644 --- a/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go +++ b/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go @@ -28,7 +28,12 @@ import ( // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *AIXExplainerSpec) DeepCopyInto(out *AIXExplainerSpec) { *out = *in - in.Resources.DeepCopyInto(&out.Resources) + if in.RuntimeVersion != nil { + in, out := &in.RuntimeVersion, &out.RuntimeVersion + *out = new(string) + **out = **in + } + in.Container.DeepCopyInto(&out.Container) if in.Config != nil { in, out := &in.Config, &out.Config *out = make(map[string]string, len(*in)) From 4bdf8fe6132db54379d82b48e81c190bb7283097 Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Wed, 16 Sep 2020 12:40:01 -0700 Subject: [PATCH 14/32] Refactor sample content and rework notebook --- .../explanation/aix/mnist/explain_image.ipynb | 196 ------------ .../aix/mnist/mnist-explanation-0015.png | Bin 572625 -> 0 bytes .../aix/mnist/mnist-explanation.png | Bin 35693 -> 572625 bytes .../explanation/aix/mnist/query_explain.ipynb | 279 ++++++++++++++++++ 4 files changed, 279 insertions(+), 196 deletions(-) delete mode 100644 docs/samples/explanation/aix/mnist/explain_image.ipynb delete mode 100644 docs/samples/explanation/aix/mnist/mnist-explanation-0015.png create mode 100644 docs/samples/explanation/aix/mnist/query_explain.ipynb diff --git a/docs/samples/explanation/aix/mnist/explain_image.ipynb b/docs/samples/explanation/aix/mnist/explain_image.ipynb deleted file mode 100644 index 196d40e9f6..0000000000 --- a/docs/samples/explanation/aix/mnist/explain_image.ipynb +++ /dev/null @@ -1,196 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## KFServing Model Explainability\n", - "\n", - "Install the necessary libraries" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Using TensorFlow backend.\n" - ] - } - ], - "source": [ - "import os\n", - "import sys\n", - "import requests\n", - "import json\n", - "from matplotlib import pyplot as plt\n", - "import numpy as np\n", - "from aix360.datasets import MNISTDataset\n", - "from keras.applications import inception_v3 as inc_net\n", - "from keras.preprocessing import image\n", - "from keras.applications.imagenet_utils import decode_predictions\n", - "import time\n", - "from skimage.color import gray2rgb, rgb2gray, label2rgb # since the code wants color images" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Pick an image and wrap it to send to the inference service." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "

" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "test_num = 1002\n", - "endpoint = \"http://limeserver.some-cluster.cloud/v1/models/limeserver:explain\"\n", - "\n", - "data = MNISTDataset()\n", - "inputs = data.test_data[test_num]\n", - "labels = data.test_labels[test_num]\n", - "actual = 0\n", - "for x in range(1, len(labels)):\n", - " if labels[x] != 0:\n", - " actual = x\n", - "inputs = gray2rgb(inputs.reshape((-1, 28, 28)))\n", - "inputs = np.reshape(inputs, (28,28,3))\n", - "input_image = {\"instances\": [inputs.tolist()]}\n", - "\n", - "fig0 = (data.test_data[test_num][:,:,0] + 0.5)*255\n", - "f, axarr = plt.subplots(1, 1, figsize=(10,10))\n", - "axarr.set_title(\"Original Image\")\n", - "axarr.imshow(fig0, cmap=\"gray\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Send the image to the inference service." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TIME TAKEN: 47.712029218673706\n", - "\n" - ] - } - ], - "source": [ - "x = time.time()\n", - "res = requests.post(endpoint, json=input_image)\n", - "\n", - "print(\"TIME TAKEN: \", time.time() - x)\n", - "print(res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Unwrap the response and display the explanations." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/site-packages/skimage/color/colorlabel.py:111: UserWarning: Negative intensities in `image` are not supported\n", - " bg_color, image_alpha)\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "res_json = res.json()\n", - "temp = np.array(res_json[\"explanations\"][\"temp\"])\n", - "masks = np.array(res_json[\"explanations\"][\"masks\"])\n", - "top_labels = np.array(res_json[\"explanations\"][\"top_labels\"])\n", - "\n", - "fig, m_axs = plt.subplots(2,5, figsize = (12,6))\n", - "for i, c_ax in enumerate(m_axs.flatten()):\n", - " mask = masks[i]\n", - " c_ax.imshow(label2rgb(mask, temp, bg_label = 0), interpolation = 'nearest')\n", - " c_ax.set_title('Positive for {}\\nActual {}'.format(top_labels[i], actual))\n", - " c_ax.axis('off')\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.7.4 64-bit", - "language": "python", - "name": "python37464biteac3a92cf4cf48d3b00e9c4589083555" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/samples/explanation/aix/mnist/mnist-explanation-0015.png b/docs/samples/explanation/aix/mnist/mnist-explanation-0015.png deleted file mode 100644 index d32fdfd64c607b6e5ed38182030d79a57d4f3623..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 572625 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

tXpN=Un8j?*DQ+gMy4X7dA_u0!x3O6QmCS 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 JIISZMaB7a#f=spJ-VQ4m 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

V}xVA4tm=Zb0 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 =5I7Bi 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

fb zDaj}|I&P*ri#xZ^F369OE3yV84xK8)6C1LDJ>>>v=+&W;;qgiby$Eu2_|V5GjLK#h z-23T02z^?%rBU*piCX|nmXuKz#D7B-Q4d0mn$CmMiDxxQmz}?fcfTweku3L>`Ah3cKv{Gz-lH~U&Zt^UySP&%td^c?4X3ii*h1SQfy!|p-D ztE*HZZW*^N0D9BqG=G`~pL4C$uVr}DVk?WzSN1@IHpYO#=Fv<3uP9CI0tT__+J^(H zlfUTC?zuc3gy9VAbOBKJL+GyPO-z*R`4>VLvIumLufQQ<4MxE66835(xK{mm`*;_X zo~AdBoK9z$_q;lUSSx8aB32HT{74Sc&Px`zC~bbaI^(XlK1H4D|E4~|q{U2ocv5Ay z<#kb+K0<995&W@PxTQ&ph_?7+s067yf{Nx`fJ97Q$F_Aa^=sK zlQb00et^wjyytpFG;|Oxxy$99i`t)EJn%Y%yMABhTB70R;GP5VJ{y7(P+c$>MQi=knZI%EHyM5QEssa5U+ zY+A{MPoe;P&QrN|{|k)Rd6@c$krzi;xj1q!)6;s|26?DQ!}TVoO5af9{>KHp0gMPH z8=iFF4CdDJkN}0*6xeyMU0xiIH?YzAJ8F_^>9;+W9pO^8TTd8#yR7+&c3IaJy%aO@ zrG)K#1S3SmY6dwy%!}iZ+=*t7uPi9=bl2MyiBpPcCj8#Di+&!aXD1keUK>*Mi}+>i z1Ue+!simWexaHDe>Z8rpR$fV6;?v_WO6X-!c@~%0DGv{P&NAxYda*&yam421msbbB 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

eh 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

tXpN=Un8j?*DQ+gMy4X7dA_u0!x3O6QmCS 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 JIISZMaB7a#f=spJ-VQ4m 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

V}xVA4tm=Zb0 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 =5I7Bi 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

G`>#c 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

fb zDaj}|I&P*ri#xZ^F369OE3yV84xK8)6C1LDJ>>>v=+&W;;qgiby$Eu2_|V5GjLK#h z-23T02z^?%rBU*piCX|nmXuKz#D7B-Q4d0mn$CmMiDxxQmz}?fcfTweku3L>`Ah3cKv{Gz-lH~U&Zt^UySP&%td^c?4X3ii*h1SQfy!|p-D ztE*HZZW*^N0D9BqG=G`~pL4C$uVr}DVk?WzSN1@IHpYO#=Fv<3uP9CI0tT__+J^(H zlfUTC?zuc3gy9VAbOBKJL+GyPO-z*R`4>VLvIumLufQQ<4MxE66835(xK{mm`*;_X zo~AdBoK9z$_q;lUSSx8aB32HT{74Sc&Px`zC~bbaI^(XlK1H4D|E4~|q{U2ocv5Ay z<#kb+K0<995&W@PxTQ&ph_?7+s067yf{Nx`fJ97Q$F_Aa^=sK zlQb00et^wjyytpFG;|Oxxy$99i`t)EJn%Y%yMABhTB70R;GP5VJ{y7(P+c$>MQi=knZI%EHyM5QEssa5U+ zY+A{MPoe;P&QrN|{|k)Rd6@c$krzi;xj1q!)6;s|26?DQ!}TVoO5af9{>KHp0gMPH z8=iFF4CdDJkN}0*6xeyMU0xiIH?YzAJ8F_^>9;+W9pO^8TTd8#yR7+&c3IaJy%aO@ zrG)K#1S3SmY6dwy%!}iZ+=*t7uPi9=bl2MyiBpPcCj8#Di+&!aXD1keUK>*Mi}+>i z1Ue+!simWexaHDe>Z8rpR$fV6;?v_WO6X-!c@~%0DGv{P&NAxYda*&yam421msbbB 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

eh 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

^!rEB}z+z%1S}CDJ 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 kYc;+cz#{(_b##xjm-TGbMkvr23HVWzRg 3:\n", + " try:\n", + " test_num = int(sys.argv[2])\n", + " except:\n", + " is_file = True\n", + "\n", + "if is_file:\n", + " inputs = open(sys.argv[2])\n", + " inputs = json.load(inputs)\n", + " actual = \"unk\"\n", + "else:\n", + " data = MNISTDataset()\n", + " inputs = data.test_data[test_num]\n", + " labels = data.test_labels[test_num]\n", + " actual = 0\n", + " for x in range(1, len(labels)):\n", + " if labels[x] != 0:\n", + " actual = x\n", + " inputs = gray2rgb(inputs.reshape((-1, 28, 28)))\n", + " inputs = np.reshape(inputs, (28,28,3))\n", + "input_image = {\"instances\": [inputs.tolist()]}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Display the input image to be used." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig0 = (inputs[:,:,0] + 0.5)*255\n", + "f, axarr = plt.subplots(1, 1, figsize=(10,10))\n", + "axarr.set_title(\"Original Image\")\n", + "axarr.imshow(fig0, cmap=\"gray\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Send the image to the inferenceservice." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sending Explain Query\n", + "TIME TAKEN: 1.2478861808776855\n" + ] + } + ], + "source": [ + "print(\"Sending Explain Query\")\n", + "\n", + "x = time.time()\n", + "\n", + "res = requests.post(endpoint, json=input_image, headers=headers)\n", + "\n", + "print(\"TIME TAKEN: \", time.time() - x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unwrap the response from the inferenceservice and display the explanations." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/site-packages/skimage/color/colorlabel.py:111: UserWarning: Negative intensities in `image` are not supported\n", + " bg_color, image_alpha)\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(res)\n", + "if not res.ok:\n", + " res.raise_for_status()\n", + "res_json = res.json()\n", + "temp = np.array(res_json[\"explanations\"][\"temp\"])\n", + "masks = np.array(res_json[\"explanations\"][\"masks\"])\n", + "top_labels = np.array(res_json[\"explanations\"][\"top_labels\"])\n", + "\n", + "fig, m_axs = plt.subplots(2,5, figsize = (12,6))\n", + "for i, c_ax in enumerate(m_axs.flatten()):\n", + " mask = masks[i]\n", + " c_ax.imshow(label2rgb(mask, temp, bg_label = 0), interpolation = 'nearest')\n", + " c_ax.set_title('Positive for {}\\nActual {}'.format(top_labels[i], actual))\n", + " c_ax.axis('off')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.4 64-bit", + "language": "python", + "name": "python37464biteac3a92cf4cf48d3b00e9c4589083555" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From a078ecd76c0a03a62f6169fc25d696f281414861 Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Fri, 18 Sep 2020 08:12:52 -0700 Subject: [PATCH 15/32] Add newline at EOF --- docs/samples/explanation/aix/mnist/rfserver/rf.Dockerfile | 2 +- .../samples/explanation/aix/mnist/rfserver/rfserver/__init__.py | 2 +- .../samples/explanation/aix/mnist/rfserver/rfserver/__main__.py | 2 +- docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py | 2 +- python/aixexplainer/aixserver/__init__.py | 2 +- python/aixexplainer/aixserver/__main__.py | 2 +- python/aixexplainer/setup.py | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/samples/explanation/aix/mnist/rfserver/rf.Dockerfile b/docs/samples/explanation/aix/mnist/rfserver/rf.Dockerfile index f978f55853..55402d15f1 100644 --- a/docs/samples/explanation/aix/mnist/rfserver/rf.Dockerfile +++ b/docs/samples/explanation/aix/mnist/rfserver/rf.Dockerfile @@ -3,4 +3,4 @@ FROM python:3.7 COPY . . RUN pip install --upgrade pip && pip install kfserving==0.4.0 RUN pip install -e . -ENTRYPOINT ["python", "-m", "rfserver", "--model_name", "aixserver"] \ No newline at end of file +ENTRYPOINT ["python", "-m", "rfserver", "--model_name", "aixserver"] diff --git a/docs/samples/explanation/aix/mnist/rfserver/rfserver/__init__.py b/docs/samples/explanation/aix/mnist/rfserver/rfserver/__init__.py index e5c00234ff..babbc83c3c 100644 --- a/docs/samples/explanation/aix/mnist/rfserver/rfserver/__init__.py +++ b/docs/samples/explanation/aix/mnist/rfserver/rfserver/__init__.py @@ -12,4 +12,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -from .model import RFModel \ No newline at end of file +from .model import RFModel diff --git a/docs/samples/explanation/aix/mnist/rfserver/rfserver/__main__.py b/docs/samples/explanation/aix/mnist/rfserver/rfserver/__main__.py index 5ed38c9a5d..623c1c98ff 100644 --- a/docs/samples/explanation/aix/mnist/rfserver/rfserver/__main__.py +++ b/docs/samples/explanation/aix/mnist/rfserver/rfserver/__main__.py @@ -28,4 +28,4 @@ if __name__ == "__main__": model = RFModel(args.model_name) model.load() - kfserving.KFServer().start([model]) \ No newline at end of file + kfserving.KFServer().start([model]) diff --git a/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py b/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py index 3ca663f3fe..3eb0397828 100644 --- a/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py +++ b/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py @@ -75,4 +75,4 @@ def predict(self, request: Dict) -> Dict: return {"predictions" : class_preds} except Exception as e: - raise Exception("Failed to predict %s" % e) \ No newline at end of file + raise Exception("Failed to predict %s" % e) diff --git a/python/aixexplainer/aixserver/__init__.py b/python/aixexplainer/aixserver/__init__.py index d51215f730..91d26be4bf 100644 --- a/python/aixexplainer/aixserver/__init__.py +++ b/python/aixexplainer/aixserver/__init__.py @@ -12,4 +12,4 @@ # See the License for the specific language governing permissions and # limitations under the License. -from .model import AIXModel \ No newline at end of file +from .model import AIXModel diff --git a/python/aixexplainer/aixserver/__main__.py b/python/aixexplainer/aixserver/__main__.py index 2016764805..6956d5ba86 100644 --- a/python/aixexplainer/aixserver/__main__.py +++ b/python/aixexplainer/aixserver/__main__.py @@ -51,4 +51,4 @@ top_labels=args.top_labels, min_weight=args.min_weight, positive_only=args.positive_only, explainer_type=args.explainer_type) model.load() - kfserving.KFServer().start([model]) \ No newline at end of file + kfserving.KFServer().start([model]) diff --git a/python/aixexplainer/setup.py b/python/aixexplainer/setup.py index 0834f0a157..b9d4c16871 100644 --- a/python/aixexplainer/setup.py +++ b/python/aixexplainer/setup.py @@ -39,4 +39,4 @@ ], tests_require=tests_require, extras_require={'test': tests_require} -) \ No newline at end of file +) From 41a056babea5acd726002fef33286b571ba67fa7 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Mon, 21 Sep 2020 11:09:31 -0700 Subject: [PATCH 16/32] generate aix SDK spec and add predictor test --- .../docs/V1alpha2AIXExplainerSpec.md | 14 + .../kfserving/docs/V1alpha2ExplainerSpec.md | 1 + python/kfserving/kfserving/models/__init__.py | 1 + .../models/v1alpha2_aix_explainer_spec.py | 246 + .../models/v1alpha2_explainer_spec.py | 31 +- test/e2e/data/mnist_input.json | 3982 +++++++++++++++++ test/e2e/explainer/test_aix_explainer.py | 84 + 7 files changed, 4358 insertions(+), 1 deletion(-) create mode 100644 python/kfserving/docs/V1alpha2AIXExplainerSpec.md create mode 100644 python/kfserving/kfserving/models/v1alpha2_aix_explainer_spec.py create mode 100644 test/e2e/data/mnist_input.json create mode 100644 test/e2e/explainer/test_aix_explainer.py diff --git a/python/kfserving/docs/V1alpha2AIXExplainerSpec.md b/python/kfserving/docs/V1alpha2AIXExplainerSpec.md new file mode 100644 index 0000000000..29910557de --- /dev/null +++ b/python/kfserving/docs/V1alpha2AIXExplainerSpec.md @@ -0,0 +1,14 @@ +# V1alpha2AIXExplainerSpec + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**config** | **dict(str, str)** | Inline custom parameter settings for explainer | [optional] +**resources** | [**V1ResourceRequirements**](https://github.com/kubernetes-client/python/blob/master/kubernetes/docs/V1ResourceRequirements.md) | Defaults to requests and limits of 1CPU, 2Gb MEM. | [optional] +**runtime_version** | **str** | Defaults to latest AIX Version | [optional] +**storage_uri** | **str** | The location of a trained explanation model | [optional] +**type** | **str** | The type of AIX explainer | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/python/kfserving/docs/V1alpha2ExplainerSpec.md b/python/kfserving/docs/V1alpha2ExplainerSpec.md index fdfa0121fc..08f4f6d20a 100644 --- a/python/kfserving/docs/V1alpha2ExplainerSpec.md +++ b/python/kfserving/docs/V1alpha2ExplainerSpec.md @@ -3,6 +3,7 @@ ## Properties Name | Type | Description | Notes ------------ | ------------- | ------------- | ------------- +**aix** | [**V1alpha2AIXExplainerSpec**](V1alpha2AIXExplainerSpec.md) | Spec for AIX explainer | [optional] **alibi** | [**V1alpha2AlibiExplainerSpec**](V1alpha2AlibiExplainerSpec.md) | Spec for alibi explainer | [optional] **batcher** | [**V1alpha2Batcher**](V1alpha2Batcher.md) | Activate request batching | [optional] **custom** | [**V1alpha2CustomSpec**](V1alpha2CustomSpec.md) | Spec for a custom explainer | [optional] diff --git a/python/kfserving/kfserving/models/__init__.py b/python/kfserving/kfserving/models/__init__.py index 90a97c1cd4..34ccfbe57b 100644 --- a/python/kfserving/kfserving/models/__init__.py +++ b/python/kfserving/kfserving/models/__init__.py @@ -33,6 +33,7 @@ from kfserving.models.knative_condition import KnativeCondition from kfserving.models.knative_url import KnativeURL from kfserving.models.knative_volatile_time import KnativeVolatileTime +from kfserving.models.v1alpha2_aix_explainer_spec import V1alpha2AIXExplainerSpec from kfserving.models.v1alpha2_alibi_explainer_spec import V1alpha2AlibiExplainerSpec from kfserving.models.v1alpha2_batcher import V1alpha2Batcher from kfserving.models.v1alpha2_custom_spec import V1alpha2CustomSpec diff --git a/python/kfserving/kfserving/models/v1alpha2_aix_explainer_spec.py b/python/kfserving/kfserving/models/v1alpha2_aix_explainer_spec.py new file mode 100644 index 0000000000..0d4eec2a62 --- /dev/null +++ b/python/kfserving/kfserving/models/v1alpha2_aix_explainer_spec.py @@ -0,0 +1,246 @@ +# Copyright 2020 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# coding: utf-8 + +""" + KFServing + + Python SDK for KFServing # noqa: E501 + + OpenAPI spec version: v0.1 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +import pprint +import re # noqa: F401 + +import six + +from kubernetes.client import V1ResourceRequirements # noqa: F401,E501 + + +class V1alpha2AIXExplainerSpec(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'config': 'dict(str, str)', + 'resources': 'V1ResourceRequirements', + 'runtime_version': 'str', + 'storage_uri': 'str', + 'type': 'str' + } + + attribute_map = { + 'config': 'config', + 'resources': 'resources', + 'runtime_version': 'runtimeVersion', + 'storage_uri': 'storageUri', + 'type': 'type' + } + + def __init__(self, config=None, resources=None, runtime_version=None, storage_uri=None, type=None): # noqa: E501 + """V1alpha2AIXExplainerSpec - a model defined in Swagger""" # noqa: E501 + + self._config = None + self._resources = None + self._runtime_version = None + self._storage_uri = None + self._type = None + self.discriminator = None + + if config is not None: + self.config = config + if resources is not None: + self.resources = resources + if runtime_version is not None: + self.runtime_version = runtime_version + if storage_uri is not None: + self.storage_uri = storage_uri + self.type = type + + @property + def config(self): + """Gets the config of this V1alpha2AIXExplainerSpec. # noqa: E501 + + Inline custom parameter settings for explainer # noqa: E501 + + :return: The config of this V1alpha2AIXExplainerSpec. # noqa: E501 + :rtype: dict(str, str) + """ + return self._config + + @config.setter + def config(self, config): + """Sets the config of this V1alpha2AIXExplainerSpec. + + Inline custom parameter settings for explainer # noqa: E501 + + :param config: The config of this V1alpha2AIXExplainerSpec. # noqa: E501 + :type: dict(str, str) + """ + + self._config = config + + @property + def resources(self): + """Gets the resources of this V1alpha2AIXExplainerSpec. # noqa: E501 + + Defaults to requests and limits of 1CPU, 2Gb MEM. # noqa: E501 + + :return: The resources of this V1alpha2AIXExplainerSpec. # noqa: E501 + :rtype: V1ResourceRequirements + """ + return self._resources + + @resources.setter + def resources(self, resources): + """Sets the resources of this V1alpha2AIXExplainerSpec. + + Defaults to requests and limits of 1CPU, 2Gb MEM. # noqa: E501 + + :param resources: The resources of this V1alpha2AIXExplainerSpec. # noqa: E501 + :type: V1ResourceRequirements + """ + + self._resources = resources + + @property + def runtime_version(self): + """Gets the runtime_version of this V1alpha2AIXExplainerSpec. # noqa: E501 + + Defaults to latest AIX Version # noqa: E501 + + :return: The runtime_version of this V1alpha2AIXExplainerSpec. # noqa: E501 + :rtype: str + """ + return self._runtime_version + + @runtime_version.setter + def runtime_version(self, runtime_version): + """Sets the runtime_version of this V1alpha2AIXExplainerSpec. + + Defaults to latest AIX Version # noqa: E501 + + :param runtime_version: The runtime_version of this V1alpha2AIXExplainerSpec. # noqa: E501 + :type: str + """ + + self._runtime_version = runtime_version + + @property + def storage_uri(self): + """Gets the storage_uri of this V1alpha2AIXExplainerSpec. # noqa: E501 + + The location of a trained explanation model # noqa: E501 + + :return: The storage_uri of this V1alpha2AIXExplainerSpec. # noqa: E501 + :rtype: str + """ + return self._storage_uri + + @storage_uri.setter + def storage_uri(self, storage_uri): + """Sets the storage_uri of this V1alpha2AIXExplainerSpec. + + The location of a trained explanation model # noqa: E501 + + :param storage_uri: The storage_uri of this V1alpha2AIXExplainerSpec. # noqa: E501 + :type: str + """ + + self._storage_uri = storage_uri + + @property + def type(self): + """Gets the type of this V1alpha2AIXExplainerSpec. # noqa: E501 + + The type of AIX explainer # noqa: E501 + + :return: The type of this V1alpha2AIXExplainerSpec. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this V1alpha2AIXExplainerSpec. + + The type of AIX explainer # noqa: E501 + + :param type: The type of this V1alpha2AIXExplainerSpec. # noqa: E501 + :type: str + """ + if type is None: + raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501 + + self._type = type + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + if issubclass(V1alpha2AIXExplainerSpec, dict): + for key, value in self.items(): + result[key] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, V1alpha2AIXExplainerSpec): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/python/kfserving/kfserving/models/v1alpha2_explainer_spec.py b/python/kfserving/kfserving/models/v1alpha2_explainer_spec.py index 2f98bfd830..033d34c525 100644 --- a/python/kfserving/kfserving/models/v1alpha2_explainer_spec.py +++ b/python/kfserving/kfserving/models/v1alpha2_explainer_spec.py @@ -30,6 +30,7 @@ import six +from kfserving.models.v1alpha2_aix_explainer_spec import V1alpha2AIXExplainerSpec # noqa: F401,E501 from kfserving.models.v1alpha2_alibi_explainer_spec import V1alpha2AlibiExplainerSpec # noqa: F401,E501 from kfserving.models.v1alpha2_batcher import V1alpha2Batcher # noqa: F401,E501 from kfserving.models.v1alpha2_custom_spec import V1alpha2CustomSpec # noqa: F401,E501 @@ -50,6 +51,7 @@ class V1alpha2ExplainerSpec(object): and the value is json key in definition. """ swagger_types = { + 'aix': 'V1alpha2AIXExplainerSpec', 'alibi': 'V1alpha2AlibiExplainerSpec', 'batcher': 'V1alpha2Batcher', 'custom': 'V1alpha2CustomSpec', @@ -61,6 +63,7 @@ class V1alpha2ExplainerSpec(object): } attribute_map = { + 'aix': 'aix', 'alibi': 'alibi', 'batcher': 'batcher', 'custom': 'custom', @@ -71,9 +74,10 @@ class V1alpha2ExplainerSpec(object): 'service_account_name': 'serviceAccountName' } - def __init__(self, alibi=None, batcher=None, custom=None, logger=None, max_replicas=None, min_replicas=None, parallelism=None, service_account_name=None): # noqa: E501 + def __init__(self, aix=None, alibi=None, batcher=None, custom=None, logger=None, max_replicas=None, min_replicas=None, parallelism=None, service_account_name=None): # noqa: E501 """V1alpha2ExplainerSpec - a model defined in Swagger""" # noqa: E501 + self._aix = None self._alibi = None self._batcher = None self._custom = None @@ -84,6 +88,8 @@ def __init__(self, alibi=None, batcher=None, custom=None, logger=None, max_repli self._service_account_name = None self.discriminator = None + if aix is not None: + self.aix = aix if alibi is not None: self.alibi = alibi if batcher is not None: @@ -101,6 +107,29 @@ def __init__(self, alibi=None, batcher=None, custom=None, logger=None, max_repli if service_account_name is not None: self.service_account_name = service_account_name + @property + def aix(self): + """Gets the aix of this V1alpha2ExplainerSpec. # noqa: E501 + + Spec for AIX explainer # noqa: E501 + + :return: The aix of this V1alpha2ExplainerSpec. # noqa: E501 + :rtype: V1alpha2AIXExplainerSpec + """ + return self._aix + + @aix.setter + def aix(self, aix): + """Sets the aix of this V1alpha2ExplainerSpec. + + Spec for AIX explainer # noqa: E501 + + :param aix: The aix of this V1alpha2ExplainerSpec. # noqa: E501 + :type: V1alpha2AIXExplainerSpec + """ + + self._aix = aix + @property def alibi(self): """Gets the alibi of this V1alpha2ExplainerSpec. # noqa: E501 diff --git a/test/e2e/data/mnist_input.json b/test/e2e/data/mnist_input.json new file mode 100644 index 0000000000..1bca17fcea --- /dev/null +++ b/test/e2e/data/mnist_input.json @@ -0,0 +1,3982 @@ +{ + "instances":[ + [ + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.39803921568627454, + -0.39803921568627454, + -0.39803921568627454 + ], + [ + -0.056862745098039236, + -0.056862745098039236, + -0.056862745098039236 + ], + [ + -0.056862745098039236, + -0.056862745098039236, + -0.056862745098039236 + ], + [ + 0.5, + 0.5, + 0.5 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + -0.2529411764705882, + -0.2529411764705882, + -0.2529411764705882 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.2019607843137255, + -0.2019607843137255, + -0.2019607843137255 + ], + [ + 0.40588235294117647, + 0.40588235294117647, + 0.40588235294117647 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.44509803921568625, + 0.44509803921568625, + 0.44509803921568625 + ], + [ + 0.08431372549019611, + 0.08431372549019611, + 0.08431372549019611 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.24117647058823527, + -0.24117647058823527, + -0.24117647058823527 + ], + [ + 0.4372549019607843, + 0.4372549019607843, + 0.4372549019607843 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.28823529411764703, + 0.28823529411764703, + 0.28823529411764703 + ], + [ + 0.2647058823529411, + 0.2647058823529411, + 0.2647058823529411 + ], + [ + 0.292156862745098, + 0.292156862745098, + 0.292156862745098 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4137254901960784, + 0.4137254901960784, + 0.4137254901960784 + ], + [ + -0.33137254901960783, + -0.33137254901960783, + -0.33137254901960783 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.24117647058823527, + -0.24117647058823527, + -0.24117647058823527 + ], + [ + -0.17058823529411765, + -0.17058823529411765, + -0.17058823529411765 + ], + [ + -0.17058823529411765, + -0.17058823529411765, + -0.17058823529411765 + ], + [ + -0.17058823529411765, + -0.17058823529411765, + -0.17058823529411765 + ], + [ + -0.4647058823529412, + -0.4647058823529412, + -0.4647058823529412 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.3862745098039216, + -0.3862745098039216, + -0.3862745098039216 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + -0.28431372549019607, + -0.28431372549019607, + -0.28431372549019607 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.44901960784313727, + -0.44901960784313727, + -0.44901960784313727 + ], + [ + 0.24117647058823533, + 0.24117647058823533, + 0.24117647058823533 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + -0.28431372549019607, + -0.28431372549019607, + -0.28431372549019607 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.1392156862745098, + -0.1392156862745098, + -0.1392156862745098 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.5, + 0.5, + 0.5 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + -0.2803921568627451, + -0.2803921568627451, + -0.2803921568627451 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.1156862745098039, + -0.1156862745098039, + -0.1156862745098039 + ], + [ + 0.4529411764705882, + 0.4529411764705882, + 0.4529411764705882 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.00588235294117645, + 0.00588235294117645, + 0.00588235294117645 + ], + [ + -0.4764705882352941, + -0.4764705882352941, + -0.4764705882352941 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.2372549019607843, + -0.2372549019607843, + -0.2372549019607843 + ], + [ + 0.4411764705882353, + 0.4411764705882353, + 0.4411764705882353 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.1470588235294118, + 0.1470588235294118, + 0.1470588235294118 + ], + [ + -0.4764705882352941, + -0.4764705882352941, + -0.4764705882352941 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.2019607843137255, + -0.2019607843137255, + -0.2019607843137255 + ], + [ + 0.2686274509803922, + 0.2686274509803922, + 0.2686274509803922 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + -0.00588235294117645, + -0.00588235294117645, + -0.00588235294117645 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + 0.24901960784313726, + 0.24901960784313726, + 0.24901960784313726 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.17843137254901964, + 0.17843137254901964, + 0.17843137254901964 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.44901960784313727, + -0.44901960784313727, + -0.44901960784313727 + ], + [ + 0.24901960784313726, + 0.24901960784313726, + 0.24901960784313726 + ], + [ + 0.5, + 0.5, + 0.5 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.1352941176470588, + 0.1352941176470588, + 0.1352941176470588 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.2019607843137255, + -0.2019607843137255, + -0.2019607843137255 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.10392156862745094, + 0.10392156862745094, + 0.10392156862745094 + ], + [ + -0.4647058823529412, + -0.4647058823529412, + -0.4647058823529412 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.2019607843137255, + -0.2019607843137255, + -0.2019607843137255 + ], + [ + 0.41764705882352937, + 0.41764705882352937, + 0.41764705882352937 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.10392156862745094, + 0.10392156862745094, + 0.10392156862745094 + ], + [ + -0.45294117647058824, + -0.45294117647058824, + -0.45294117647058824 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.44901960784313727, + -0.44901960784313727, + -0.44901960784313727 + ], + [ + -0.3862745098039216, + -0.3862745098039216, + -0.3862745098039216 + ], + [ + 0.29607843137254897, + 0.29607843137254897, + 0.29607843137254897 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.19803921568627447, + 0.19803921568627447, + 0.19803921568627447 + ], + [ + -0.4647058823529412, + -0.4647058823529412, + -0.4647058823529412 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.056862745098039236, + -0.056862745098039236, + -0.056862745098039236 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + -0.2529411764705882, + -0.2529411764705882, + -0.2529411764705882 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.44901960784313727, + -0.44901960784313727, + -0.44901960784313727 + ], + [ + -0.056862745098039236, + -0.056862745098039236, + -0.056862745098039236 + ], + [ + 0.5, + 0.5, + 0.5 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4411764705882353, + 0.4411764705882353, + 0.4411764705882353 + ], + [ + -0.2529411764705882, + -0.2529411764705882, + -0.2529411764705882 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.15098039215686276, + -0.15098039215686276, + -0.15098039215686276 + ], + [ + -0.056862745098039236, + -0.056862745098039236, + -0.056862745098039236 + ], + [ + -0.056862745098039236, + -0.056862745098039236, + -0.056862745098039236 + ], + [ + 0.05294117647058827, + 0.05294117647058827, + 0.05294117647058827 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.2019607843137255, + -0.2019607843137255, + -0.2019607843137255 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4137254901960784, + 0.4137254901960784, + 0.4137254901960784 + ], + [ + -0.16666666666666669, + -0.16666666666666669, + -0.16666666666666669 + ], + [ + 0.07647058823529407, + 0.07647058823529407, + 0.07647058823529407 + ], + [ + 0.38235294117647056, + 0.38235294117647056, + 0.38235294117647056 + ], + [ + 0.4647058823529412, + 0.4647058823529412, + 0.4647058823529412 + ], + [ + 0.4490196078431372, + 0.4490196078431372, + 0.4490196078431372 + ], + [ + 0.15490196078431373, + 0.15490196078431373, + 0.15490196078431373 + ], + [ + -0.13137254901960782, + -0.13137254901960782, + -0.13137254901960782 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.32352941176470584, + -0.32352941176470584, + -0.32352941176470584 + ], + [ + 0.41764705882352937, + 0.41764705882352937, + 0.41764705882352937 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4137254901960784, + 0.4137254901960784, + 0.4137254901960784 + ], + [ + 0.2647058823529411, + 0.2647058823529411, + 0.2647058823529411 + ], + [ + -0.12352941176470589, + -0.12352941176470589, + -0.12352941176470589 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.42549019607843136, + -0.42549019607843136, + -0.42549019607843136 + ], + [ + 0.1941176470588235, + 0.1941176470588235, + 0.1941176470588235 + ], + [ + 0.37450980392156863, + 0.37450980392156863, + 0.37450980392156863 + ], + [ + 0.49215686274509807, + 0.49215686274509807, + 0.49215686274509807 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4882352941176471, + 0.4882352941176471, + 0.4882352941176471 + ], + [ + 0.4764705882352941, + 0.4764705882352941, + 0.4764705882352941 + ], + [ + 0.37450980392156863, + 0.37450980392156863, + 0.37450980392156863 + ], + [ + 0.38235294117647056, + 0.38235294117647056, + 0.38235294117647056 + ], + [ + -0.22156862745098038, + -0.22156862745098038, + -0.22156862745098038 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.0607843137254902, + -0.0607843137254902, + -0.0607843137254902 + ], + [ + -0.0607843137254902, + -0.0607843137254902, + -0.0607843137254902 + ], + [ + 0.24117647058823533, + 0.24117647058823533, + 0.24117647058823533 + ], + [ + -0.11176470588235293, + -0.11176470588235293, + -0.11176470588235293 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ], + [ + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ], + [ + -0.5, + -0.5, + -0.5 + ] + ] + ] + ] + } diff --git a/test/e2e/explainer/test_aix_explainer.py b/test/e2e/explainer/test_aix_explainer.py new file mode 100644 index 0000000000..fdf6720e0a --- /dev/null +++ b/test/e2e/explainer/test_aix_explainer.py @@ -0,0 +1,84 @@ +# Copyright 2019 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import logging + +from kubernetes import client + +from kfserving import KFServingClient +from kfserving import constants +from kfserving import V1alpha2EndpointSpec +from kfserving import V1alpha2PredictorSpec +from kfserving import V1alpha2InferenceServiceSpec +from kfserving import V1alpha2ExplainerSpec +from kfserving import V1alpha2AIXExplainerSpec +from kfserving import V1alpha2InferenceService +from kfserving import V1alpha2CustomSpec +from kubernetes.client import V1ResourceRequirements +from kubernetes.client import V1Container + +from ..common.utils import predict +from ..common.utils import explain +from ..common.utils import KFSERVING_TEST_NAMESPACE + +logging.basicConfig(level=logging.INFO) +api_version = constants.KFSERVING_GROUP + '/' + constants.KFSERVING_VERSION +KFServing = KFServingClient(config_file="~/.kube/config") + + +def test_tabular_explainer(): + service_name = 'aix-explainer' + default_endpoint_spec = V1alpha2EndpointSpec( + predictor=V1alpha2PredictorSpec( + custom=V1alpha2CustomSpec( + container=V1Container( + name="predictor", + image='aipipeline/rf-predictor:0.4.0', + command=["python", "-m", "rfserver", "--model_name", "aix-explainer"] + ), + resources=V1ResourceRequirements( + requests={'cpu': '1', 'memory': '2Gi'}, + limits={'cpu': '1', 'memory': '2Gi'}))), + explainer=V1alpha2ExplainerSpec( + min_replicas=1, + aix=V1alpha2AIXExplainerSpec( + type='LimeImages', + resources=V1ResourceRequirements( + requests={'cpu': '1', 'memory': '2Gi'}, + limits={'cpu': '1', 'memory': '2Gi'})))) + + isvc = V1alpha2InferenceService(api_version=api_version, + kind=constants.KFSERVING_KIND, + metadata=client.V1ObjectMeta( + name=service_name, namespace=KFSERVING_TEST_NAMESPACE), + spec=V1alpha2InferenceServiceSpec(default=default_endpoint_spec)) + + KFServing.create(isvc) + try: + KFServing.wait_isvc_ready(service_name, namespace=KFSERVING_TEST_NAMESPACE, timeout_seconds=720) + except RuntimeError as e: + logging.info(KFServing.api_instance.get_namespaced_custom_object("serving.knative.dev", "v1", + KFSERVING_TEST_NAMESPACE, "services", service_name + "-predictor-default")) + pods = KFServing.core_api.list_namespaced_pod(KFSERVING_TEST_NAMESPACE, + label_selector='serving.kubeflow.org/inferenceservice={}'.format(service_name)) + for pod in pods.items: + logging.info(pod) + raise e + + res = predict(service_name, './data/mnist_input.json') + assert(res["predictions"] == [[0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]) + # TODO: add explain test + # precision = explain(service_name, './data/mnist_input.json') + # assert(precision > 0.9) + KFServing.delete(service_name, KFSERVING_TEST_NAMESPACE) From e0c267be42ebf530e9be17e370d93e6b4817e105 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Mon, 21 Sep 2020 11:11:53 -0700 Subject: [PATCH 17/32] generate aix SDK spec and add predictor test --- .../test/test_v1alpha2_aix_explainer_spec.py | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 python/kfserving/test/test_v1alpha2_aix_explainer_spec.py diff --git a/python/kfserving/test/test_v1alpha2_aix_explainer_spec.py b/python/kfserving/test/test_v1alpha2_aix_explainer_spec.py new file mode 100644 index 0000000000..3c5133d276 --- /dev/null +++ b/python/kfserving/test/test_v1alpha2_aix_explainer_spec.py @@ -0,0 +1,54 @@ +# Copyright 2020 kubeflow.org. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# coding: utf-8 + +""" + KFServing + + Python SDK for KFServing # noqa: E501 + + OpenAPI spec version: v0.1 + + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +import unittest + +import kfserving +from kfserving.models.v1alpha2_aix_explainer_spec import V1alpha2AIXExplainerSpec # noqa: E501 +from kfserving.rest import ApiException + + +class TestV1alpha2AIXExplainerSpec(unittest.TestCase): + """V1alpha2AIXExplainerSpec unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testV1alpha2AIXExplainerSpec(self): + """Test V1alpha2AIXExplainerSpec""" + # FIXME: construct object with mandatory attributes with example values + # model = kfserving.models.v1alpha2_aix_explainer_spec.V1alpha2AIXExplainerSpec() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() From 4bda3afa5812ad13048eab36c31e8e18198424ce Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Mon, 21 Sep 2020 11:40:16 -0700 Subject: [PATCH 18/32] add aix explainer build test --- test/workflows/components/workflows.libsonnet | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/workflows/components/workflows.libsonnet b/test/workflows/components/workflows.libsonnet index 2d8277eaa9..f67821f05c 100644 --- a/test/workflows/components/workflows.libsonnet +++ b/test/workflows/components/workflows.libsonnet @@ -229,6 +229,10 @@ name: "build-alibi-explainer", template: "build-alibi-explainer", }, + { + name: "build-aix-explainer", + template: "build-aix-explainer", + }, { name: "build-storage-initializer", template: "build-storage-initializer", @@ -323,6 +327,9 @@ $.parts(namespace, name, overrides).e2e(prow_env, bucket).buildTemplate("build-alibi-explainer", testWorkerImage, [ "test/scripts/build-python-image.sh", "alibiexplainer.Dockerfile", "alibi-explainer", "latest" ]), // build-alibi-explainer + $.parts(namespace, name, overrides).e2e(prow_env, bucket).buildTemplate("build-aix-explainer", testWorkerImage, [ + "test/scripts/build-python-image.sh", "aixexplainer.Dockerfile ", "aix-explainer", "latest" + ]), // build-aix-explainer $.parts(namespace, name, overrides).e2e(prow_env, bucket).buildTemplate("build-storage-initializer", testWorkerImage, [ "test/scripts/build-python-image.sh", "storage-initializer.Dockerfile", "storage-initializer", "latest" ]), // build-storage-initializer From 2a3b8a427980ab232484b6783f0705fbe5bd9eb6 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Mon, 21 Sep 2020 12:53:12 -0700 Subject: [PATCH 19/32] add missing __init__.py --- python/kfserving/kfserving/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/python/kfserving/kfserving/__init__.py b/python/kfserving/kfserving/__init__.py index 3d260980c5..1eba7eaa6d 100644 --- a/python/kfserving/kfserving/__init__.py +++ b/python/kfserving/kfserving/__init__.py @@ -35,6 +35,7 @@ from .models.knative_volatile_time import KnativeVolatileTime from .models.net_url_userinfo import NetUrlUserinfo from .models.v1alpha2_alibi_explainer_spec import V1alpha2AlibiExplainerSpec +from .models.v1alpha2_aix_explainer_spec import V1alpha2AIXExplainerSpec from .models.v1alpha2_batcher import V1alpha2Batcher from .models.v1alpha2_custom_spec import V1alpha2CustomSpec from .models.v1alpha2_inference_service import V1alpha2InferenceService From bfe2a26fe6bae9b2235bcd264fc6220e244d93ae Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Mon, 21 Sep 2020 13:42:28 -0700 Subject: [PATCH 20/32] Add explanation e2e check --- test/e2e/common/utils.py | 13 +++++++++++-- test/e2e/explainer/test_aix_explainer.py | 11 +++++++---- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/test/e2e/common/utils.py b/test/e2e/common/utils.py index 5327266c3d..0180eefa74 100644 --- a/test/e2e/common/utils.py +++ b/test/e2e/common/utils.py @@ -43,7 +43,16 @@ def predict(service_name, input_json): return preds + def explain(service_name, input_json): + return explain_response(service_name, input_json)["data"]["precision"] + + +def explain_aix(service_name, input_json): + return explain_response(service_name, input_json)["data"]["masks"][0] + + +def explain_response(service_name, input_json): isvc = KFServing.get(service_name, namespace=KFSERVING_TEST_NAMESPACE) # temporary sleep until this is fixed https://github.com/kubeflow/kfserving/issues/604 time.sleep(10) @@ -62,7 +71,7 @@ def explain(service_name, input_json): try: response = requests.post(url, json.dumps(data), headers=headers) logging.info("Got response code %s, content %s", response.status_code, response.content) - precision = json.loads(response.content.decode('utf-8'))["data"]["precision"] + json_response = json.loads(response.content.decode('utf-8')) except (RuntimeError, json.decoder.JSONDecodeError) as e: logging.info("Explain error -------") logging.info(KFServing.api_instance.get_namespaced_custom_object("serving.knative.dev", "v1", KFSERVING_TEST_NAMESPACE, @@ -79,7 +88,7 @@ def explain(service_name, input_json): KFSERVING_TEST_NAMESPACE, container="kfserving-container") logging.info(api_response) raise e - return precision + return json_response def get_cluster_ip(): diff --git a/test/e2e/explainer/test_aix_explainer.py b/test/e2e/explainer/test_aix_explainer.py index fdf6720e0a..3a678d618f 100644 --- a/test/e2e/explainer/test_aix_explainer.py +++ b/test/e2e/explainer/test_aix_explainer.py @@ -29,9 +29,11 @@ from kubernetes.client import V1Container from ..common.utils import predict -from ..common.utils import explain +from ..common.utils import explain_aix from ..common.utils import KFSERVING_TEST_NAMESPACE +import numpy as np + logging.basicConfig(level=logging.INFO) api_version = constants.KFSERVING_GROUP + '/' + constants.KFSERVING_VERSION KFServing = KFServingClient(config_file="~/.kube/config") @@ -78,7 +80,8 @@ def test_tabular_explainer(): res = predict(service_name, './data/mnist_input.json') assert(res["predictions"] == [[0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]) - # TODO: add explain test - # precision = explain(service_name, './data/mnist_input.json') - # assert(precision > 0.9) + + mask = explain_aix(service_name, './data/mnist_input.json') + percent_in_mask = np.count_nonzero(mask) / np.size(np.array(mask)) + assert(percent_in_mask > 0.6) KFServing.delete(service_name, KFSERVING_TEST_NAMESPACE) From f2c4cf643c26b149584707c65cac211790ee3a71 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Mon, 21 Sep 2020 14:30:30 -0700 Subject: [PATCH 21/32] fix containerv1 spec --- test/e2e/explainer/test_aix_explainer.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/test/e2e/explainer/test_aix_explainer.py b/test/e2e/explainer/test_aix_explainer.py index fdf6720e0a..ce2a69ee24 100644 --- a/test/e2e/explainer/test_aix_explainer.py +++ b/test/e2e/explainer/test_aix_explainer.py @@ -45,11 +45,11 @@ def test_tabular_explainer(): container=V1Container( name="predictor", image='aipipeline/rf-predictor:0.4.0', - command=["python", "-m", "rfserver", "--model_name", "aix-explainer"] - ), - resources=V1ResourceRequirements( - requests={'cpu': '1', 'memory': '2Gi'}, - limits={'cpu': '1', 'memory': '2Gi'}))), + command=["python", "-m", "rfserver", "--model_name", "aix-explainer"], + resources=V1ResourceRequirements( + requests={'cpu': '1', 'memory': '2Gi'}, + limits={'cpu': '1', 'memory': '2Gi'}) + ))), explainer=V1alpha2ExplainerSpec( min_replicas=1, aix=V1alpha2AIXExplainerSpec( From ddd0b8feefc7f902413d78dd8d8fe1ddea376df4 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Tue, 22 Sep 2020 12:08:33 -0700 Subject: [PATCH 22/32] rebase api spec --- ...erving.kubeflow.org_inferenceservices.yaml | 7256 ++++++----------- pkg/apis/serving/v1beta1/explainer.go | 2 - .../serving/v1beta1/zz_generated.deepcopy.go | 5 - 3 files changed, 2353 insertions(+), 4910 deletions(-) diff --git a/config/crd/serving.kubeflow.org_inferenceservices.yaml b/config/crd/serving.kubeflow.org_inferenceservices.yaml index 8591a30ace..50ff2517a8 100644 --- a/config/crd/serving.kubeflow.org_inferenceservices.yaml +++ b/config/crd/serving.kubeflow.org_inferenceservices.yaml @@ -4028,170 +4028,89 @@ spec: nodeAffinity: properties: preferredDuringSchedulingIgnoredDuringExecution: - allOf: - - 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 - weight: - format: int32 - type: integer - required: - - preference - - weight - type: object - - 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: + items: + properties: + preference: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: type: string - operator: + type: array + required: + - key + - operator + type: object + type: array + matchFields: + items: + properties: + key: + type: string + operator: + type: string + values: + items: type: string - values: - items: - type: string - type: array - required: - - key - - operator - type: object - type: array - type: object - weight: - format: int32 - type: integer - required: - - preference - - weight - type: object + type: array + required: + - key + - operator + type: object + type: array + type: object + weight: + format: int32 + type: integer + required: + - preference + - weight + type: object type: array requiredDuringSchedulingIgnoredDuringExecution: properties: nodeSelectorTerms: - allOf: - - 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 - - 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: + items: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: type: string - operator: + type: array + required: + - key + - operator + type: object + type: array + matchFields: + items: + properties: + key: + type: string + operator: + type: string + values: + items: type: string - values: - items: - type: string - type: array - required: - - key - - operator - type: object - type: array - type: object + type: array + required: + - key + - operator + type: object + type: array + type: object type: array required: - nodeSelectorTerms @@ -4200,327 +4119,169 @@ spec: podAffinity: properties: preferredDuringSchedulingIgnoredDuringExecution: - allOf: - - items: - properties: - podAffinityTerm: - properties: - labelSelector: - properties: - matchExpressions: - items: - properties: - key: - type: string - operator: + items: + properties: + podAffinityTerm: + properties: + labelSelector: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: type: string - values: - items: - type: string - type: array - required: - - key - - operator - type: object - type: array - matchLabels: - additionalProperties: - type: string + type: array + required: + - key + - operator type: object - type: object - namespaces: - items: - type: string - type: array - topologyKey: + type: array + matchLabels: + additionalProperties: + type: string + type: object + type: object + namespaces: + items: type: string - required: - - topologyKey - type: object - weight: - format: int32 - type: integer - required: - - podAffinityTerm - - weight - type: object - - items: - properties: - podAffinityTerm: - properties: - labelSelector: + 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: - matchExpressions: + key: + type: string + operator: + type: string + values: 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: array + required: + - key + - operator type: object - namespaces: - items: - type: string - type: array - topologyKey: + type: array + matchLabels: + additionalProperties: type: string - required: - - topologyKey - type: object - weight: - format: int32 - type: integer - required: - - podAffinityTerm - - weight - type: object - type: array - requiredDuringSchedulingIgnoredDuringExecution: - allOf: - - 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 - namespaces: - items: - type: string - type: array - topologyKey: - type: string - required: - - topologyKey - type: object - - 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 - namespaces: - items: - type: string - type: array - topologyKey: + type: object + type: object + namespaces: + items: type: string - required: - - topologyKey - type: object + type: array + topologyKey: + type: string + required: + - topologyKey + type: object type: array type: object podAntiAffinity: properties: preferredDuringSchedulingIgnoredDuringExecution: - allOf: - - items: - properties: - podAffinityTerm: - properties: - labelSelector: - properties: - matchExpressions: - items: - properties: - key: - type: string - operator: + items: + properties: + podAffinityTerm: + properties: + labelSelector: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: type: string - values: - items: - type: string - type: array - required: - - key - - operator - type: object - type: array - matchLabels: - additionalProperties: - type: string + type: array + required: + - key + - operator type: object - type: object - namespaces: - items: - type: string - type: array - topologyKey: + type: array + matchLabels: + additionalProperties: + type: string + type: object + type: object + namespaces: + items: type: string - required: - - topologyKey - type: object - weight: - format: int32 - type: integer - required: - - podAffinityTerm - - weight - type: object - - items: - properties: - podAffinityTerm: - properties: - labelSelector: + 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: - matchExpressions: + key: + type: string + operator: + type: string + values: 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: array + required: + - key + - operator type: object - namespaces: - items: - type: string - type: array - topologyKey: + type: array + matchLabels: + additionalProperties: type: string - required: - - topologyKey - type: object - weight: - format: int32 - type: integer - required: - - podAffinityTerm - - weight - type: object - type: array - requiredDuringSchedulingIgnoredDuringExecution: - allOf: - - 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 - namespaces: - items: - type: string - type: array - topologyKey: - type: string - required: - - topologyKey - type: object - - 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 - namespaces: - items: - type: string - type: array - topologyKey: + type: object + type: object + namespaces: + items: type: string - required: - - topologyKey - type: object + type: array + topologyKey: + type: string + required: + - topologyKey + type: object type: array type: object type: object @@ -5610,4740 +5371,2429 @@ spec: format: int64 type: integer containers: - allOf: - - items: - properties: - args: - items: - type: string - type: array - command: - items: - type: string - type: array - env: - items: - properties: - name: - type: string - value: - type: string - valueFrom: - properties: - configMapKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - secretKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - type: object - required: - - name - type: object - type: array - envFrom: - items: - properties: - configMapRef: - properties: - name: - type: string - optional: - type: boolean - type: object - prefix: - type: string - secretRef: - properties: - name: - type: string - optional: - type: boolean - type: object - type: object - type: array - image: + items: + properties: + args: + items: type: string - imagePullPolicy: + type: array + command: + items: type: string - lifecycle: + type: array + env: + items: properties: - postStart: + name: + type: string + value: + type: string + valueFrom: properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - httpGet: + configMapKeyRef: properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: + key: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: + name: type: string + optional: + type: boolean required: - - port + - key type: object - tcpSocket: + fieldRef: properties: - host: + apiVersion: + type: string + fieldPath: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true required: - - port - type: object - type: object - preStop: - properties: - exec: - properties: - command: - items: - type: string - type: array + - fieldPath type: object - httpGet: + resourceFieldRef: properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: + containerName: type: string - port: + divisor: 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 - scheme: + resource: type: string required: - - port + - resource type: object - tcpSocket: + secretKeyRef: properties: - host: + key: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true + name: + type: string + optional: + type: boolean required: - - port + - key type: object type: object + required: + - name type: object - livenessProbe: + type: array + envFrom: + items: properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: + configMapRef: properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: + name: type: string - required: - - port + optional: + type: boolean type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: + prefix: + type: string + secretRef: properties: - host: + name: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port + optional: + type: boolean type: object - timeoutSeconds: - format: int32 - type: integer type: object - name: - type: string - ports: - items: + type: array + image: + type: string + imagePullPolicy: + type: string + lifecycle: + properties: + postStart: properties: - containerPort: - format: int32 - type: integer - hostIP: - type: string - hostPort: - format: int32 - type: integer - name: - type: string - protocol: - type: string - required: - - containerPort - type: object - type: array - x-kubernetes-list-map-keys: - - containerPort - - protocol - x-kubernetes-list-type: map - readinessProbe: - properties: - exec: - properties: - command: - items: + exec: + properties: + command: + items: + type: string + type: array + type: object + httpGet: + properties: + host: type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: + type: string + required: + - port + type: object + tcpSocket: + properties: + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + type: object + preStop: + properties: + exec: + properties: + command: + items: + type: string + type: array + type: object + httpGet: + properties: + host: + type: string + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: + type: string + required: + - port + type: object + tcpSocket: + properties: + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + type: object + type: object + livenessProbe: + properties: + exec: + properties: + command: + items: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - resources: - properties: - limits: - additionalProperties: + type: array + type: object + failureThreshold: + format: int32 + type: integer + httpGet: + properties: + host: + type: string + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: 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 - type: object - requests: - additionalProperties: + scheme: + type: string + required: + - port + type: object + initialDelaySeconds: + format: int32 + type: integer + periodSeconds: + format: int32 + type: integer + successThreshold: + format: int32 + type: integer + tcpSocket: + properties: + host: + type: string + port: 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 - type: object - type: object - securityContext: + required: + - port + type: object + timeoutSeconds: + format: int32 + type: integer + type: object + name: + type: string + ports: + items: properties: - allowPrivilegeEscalation: - type: boolean - capabilities: - properties: - add: - items: - type: string - type: array - drop: - items: - type: string - type: array - type: object - privileged: - type: boolean - procMount: - type: string - readOnlyRootFilesystem: - type: boolean - runAsGroup: - format: int64 - type: integer - runAsNonRoot: - type: boolean - runAsUser: - format: int64 + containerPort: + format: int32 type: integer - seLinuxOptions: - properties: - level: - type: string - role: - type: string - type: - type: string - user: - type: string - type: object - windowsOptions: - properties: - gmsaCredentialSpec: - type: string - gmsaCredentialSpecName: - type: string - runAsUserName: - type: string - type: object - type: object - startupProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: + hostIP: + type: string + hostPort: format: int32 type: integer - httpGet: - properties: - host: + name: + type: string + protocol: + type: string + required: + - containerPort + type: object + type: array + x-kubernetes-list-map-keys: + - containerPort + - protocol + x-kubernetes-list-type: map + readinessProbe: + properties: + exec: + properties: + command: + items: type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - stdin: - type: boolean - stdinOnce: - type: boolean - terminationMessagePath: - type: string - terminationMessagePolicy: - type: string - tty: - type: boolean - volumeDevices: - items: + type: array + type: object + failureThreshold: + format: int32 + type: integer + httpGet: properties: - devicePath: + host: type: string - name: + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: type: string required: - - devicePath - - name + - port type: object - type: array - volumeMounts: - items: + initialDelaySeconds: + format: int32 + type: integer + periodSeconds: + format: int32 + type: integer + successThreshold: + format: int32 + type: integer + tcpSocket: properties: - mountPath: + host: type: string - mountPropagation: + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + timeoutSeconds: + format: int32 + type: integer + type: object + resources: + properties: + 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 + 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 + type: object + type: object + securityContext: + properties: + allowPrivilegeEscalation: + type: boolean + capabilities: + properties: + add: + items: + type: string + type: array + drop: + items: + type: string + type: array + type: object + privileged: + type: boolean + procMount: + type: string + readOnlyRootFilesystem: + type: boolean + runAsGroup: + format: int64 + type: integer + runAsNonRoot: + type: boolean + runAsUser: + format: int64 + type: integer + seLinuxOptions: + properties: + level: type: string - name: + role: type: string - readOnly: - type: boolean - subPath: + type: type: string - subPathExpr: + user: type: string - required: - - mountPath - - name type: object - type: array - workingDir: - type: string - required: - - name - type: object - - items: - properties: - args: - items: - type: string - type: array - command: - items: - type: string - type: array - env: - items: + windowsOptions: properties: - name: + gmsaCredentialSpec: type: string - value: + gmsaCredentialSpecName: + type: string + runAsUserName: type: string - valueFrom: - properties: - configMapKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - secretKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - type: object - required: - - name type: object - type: array - envFrom: - items: + type: object + startupProbe: + properties: + exec: properties: - configMapRef: - properties: - name: - type: string - optional: - type: boolean - type: object - prefix: - type: string - secretRef: - properties: - name: - type: string - optional: - type: boolean - type: object + command: + items: + type: string + type: array type: object - type: array - image: - type: string - imagePullPolicy: - type: string - lifecycle: - properties: - postStart: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - httpGet: + failureThreshold: + format: int32 + type: integer + httpGet: + properties: + host: + type: string + httpHeaders: + items: properties: - host: + name: type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: + value: type: string required: - - port + - name + - value type: object - tcpSocket: + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: + type: string + required: + - port + type: object + initialDelaySeconds: + format: int32 + type: integer + periodSeconds: + format: int32 + type: integer + successThreshold: + format: int32 + type: integer + tcpSocket: + properties: + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + timeoutSeconds: + format: int32 + type: integer + type: object + stdin: + type: boolean + stdinOnce: + type: boolean + terminationMessagePath: + type: string + terminationMessagePolicy: + type: string + tty: + type: boolean + volumeDevices: + items: + properties: + devicePath: + type: string + name: + type: string + required: + - devicePath + - name + type: object + type: array + volumeMounts: + items: + properties: + mountPath: + type: string + mountPropagation: + type: string + name: + type: string + readOnly: + type: boolean + subPath: + type: string + subPathExpr: + type: string + required: + - mountPath + - name + type: object + type: array + workingDir: + type: string + required: + - name + type: object + type: array + dnsConfig: + properties: + nameservers: + items: + type: string + type: array + options: + items: + properties: + name: + type: string + value: + type: string + type: object + type: array + searches: + items: + type: string + type: array + type: object + dnsPolicy: + type: string + enableServiceLinks: + type: boolean + ephemeralContainers: + items: + properties: + args: + items: + type: string + type: array + command: + items: + type: string + type: array + env: + items: + properties: + name: + type: string + value: + type: string + valueFrom: + properties: + configMapKeyRef: properties: - host: + key: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true + name: + type: string + optional: + type: boolean required: - - port + - key type: object - type: object - preStop: - properties: - exec: + fieldRef: properties: - command: - items: - type: string - type: array + apiVersion: + type: string + fieldPath: + type: string + required: + - fieldPath type: object - httpGet: + resourceFieldRef: properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: + containerName: type: string - port: + divisor: 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 - scheme: + resource: type: string required: - - port + - resource type: object - tcpSocket: + secretKeyRef: properties: - host: + key: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true + name: + type: string + optional: + type: boolean required: - - port + - key type: object type: object + required: + - name type: object - livenessProbe: + type: array + envFrom: + items: properties: - exec: + configMapRef: properties: - command: - items: - type: string - type: array + name: + type: string + optional: + type: boolean type: object - failureThreshold: - format: int32 - type: integer - httpGet: + prefix: + type: string + secretRef: properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: + name: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port + optional: + type: boolean type: object - timeoutSeconds: - format: int32 - type: integer type: object - name: - type: string - ports: - items: + type: array + image: + type: string + imagePullPolicy: + type: string + lifecycle: + properties: + postStart: properties: - containerPort: - format: int32 - type: integer - hostIP: + exec: + properties: + command: + items: + type: string + type: array + type: object + httpGet: + properties: + host: + type: string + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: + type: string + required: + - port + type: object + tcpSocket: + properties: + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + type: object + preStop: + properties: + exec: + properties: + command: + items: + type: string + type: array + type: object + httpGet: + properties: + host: + type: string + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: + type: string + required: + - port + type: object + tcpSocket: + properties: + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + type: object + type: object + livenessProbe: + properties: + exec: + properties: + command: + items: + type: string + type: array + type: object + failureThreshold: + format: int32 + type: integer + httpGet: + properties: + host: type: string - hostPort: - format: int32 - type: integer - name: + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: type: string - protocol: + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: type: string required: - - containerPort + - port type: object - type: array - x-kubernetes-list-map-keys: - - containerPort - - protocol - x-kubernetes-list-type: map - readinessProbe: + initialDelaySeconds: + format: int32 + type: integer + periodSeconds: + format: int32 + type: integer + successThreshold: + format: int32 + type: integer + tcpSocket: + properties: + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + timeoutSeconds: + format: int32 + type: integer + type: object + name: + type: string + ports: + items: properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: + containerPort: format: int32 type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: + hostIP: + type: string + hostPort: format: int32 type: integer + name: + type: string + protocol: + type: string + required: + - containerPort type: object - resources: - properties: - limits: - additionalProperties: + type: array + readinessProbe: + properties: + exec: + properties: + command: + items: + type: string + type: array + type: object + failureThreshold: + format: int32 + type: integer + httpGet: + properties: + host: + type: string + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: 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 - type: object - requests: - additionalProperties: + scheme: + type: string + required: + - port + type: object + initialDelaySeconds: + format: int32 + type: integer + periodSeconds: + format: int32 + type: integer + successThreshold: + format: int32 + type: integer + tcpSocket: + properties: + host: + type: string + port: 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 - type: object - type: object - securityContext: - properties: - allowPrivilegeEscalation: - type: boolean - capabilities: - properties: - add: - items: - type: string - type: array - drop: - items: - type: string - type: array - type: object - privileged: - type: boolean - procMount: - type: string - readOnlyRootFilesystem: - type: boolean - runAsGroup: - format: int64 - type: integer - runAsNonRoot: - type: boolean - runAsUser: - format: int64 - type: integer - seLinuxOptions: - properties: - level: - type: string - role: - type: string - type: - type: string - user: - type: string - type: object - windowsOptions: - properties: - gmsaCredentialSpec: - type: string - gmsaCredentialSpecName: - type: string - runAsUserName: - type: string - type: object - type: object - startupProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: + required: + - port + type: object + timeoutSeconds: + format: int32 + type: integer + type: object + resources: + properties: + 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 + 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 + type: object + type: object + securityContext: + properties: + allowPrivilegeEscalation: + type: boolean + capabilities: + properties: + add: + items: type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: + type: array + drop: + items: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - stdin: - type: boolean - stdinOnce: - type: boolean - terminationMessagePath: - type: string - terminationMessagePolicy: - type: string - tty: - type: boolean - volumeDevices: - items: + type: array + type: object + privileged: + type: boolean + procMount: + type: string + readOnlyRootFilesystem: + type: boolean + runAsGroup: + format: int64 + type: integer + runAsNonRoot: + type: boolean + runAsUser: + format: int64 + type: integer + seLinuxOptions: properties: - devicePath: + level: type: string - name: + role: type: string - required: - - devicePath - - name - type: object - type: array - volumeMounts: - items: - properties: - mountPath: + type: type: string - mountPropagation: + user: type: string - name: + type: object + windowsOptions: + properties: + gmsaCredentialSpec: type: string - readOnly: - type: boolean - subPath: + gmsaCredentialSpecName: type: string - subPathExpr: + runAsUserName: type: string - required: - - mountPath - - name type: object - type: array - workingDir: - type: string - required: - - name - type: object - type: array - dnsConfig: - properties: - nameservers: - allOf: - - items: - type: string - - items: - type: string - type: array - options: - allOf: - - items: - properties: - name: + type: object + startupProbe: + properties: + exec: + properties: + command: + items: + type: string + type: array + type: object + failureThreshold: + format: int32 + type: integer + httpGet: + properties: + host: + type: string + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: + type: string + required: + - port + type: object + initialDelaySeconds: + format: int32 + type: integer + periodSeconds: + format: int32 + type: integer + successThreshold: + format: int32 + type: integer + tcpSocket: + properties: + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + timeoutSeconds: + format: int32 + type: integer + type: object + stdin: + type: boolean + stdinOnce: + type: boolean + targetContainerName: + type: string + terminationMessagePath: + type: string + terminationMessagePolicy: + type: string + tty: + type: boolean + volumeDevices: + items: + properties: + devicePath: type: string - value: + name: type: string + required: + - devicePath + - name type: object - - items: + type: array + volumeMounts: + items: properties: + mountPath: + type: string + mountPropagation: + type: string name: type: string - value: + readOnly: + type: boolean + subPath: + type: string + subPathExpr: type: string + required: + - mountPath + - name type: object - type: array - searches: - allOf: - - items: - type: string - - items: + type: array + workingDir: + type: string + required: + - name + type: object + type: array + hostAliases: + items: + properties: + hostnames: + items: type: string - type: array - type: object - dnsPolicy: - type: string - enableServiceLinks: + type: array + ip: + type: string + type: object + type: array + hostIPC: type: boolean - ephemeralContainers: - allOf: - - items: - properties: - args: - items: - type: string - type: array - command: - items: - type: string - type: array - env: - items: - properties: - name: - type: string - value: - type: string - valueFrom: - properties: - configMapKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - secretKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - type: object - required: - - name - type: object - type: array - envFrom: - items: - properties: - configMapRef: - properties: - name: - type: string - optional: - type: boolean - type: object - prefix: - type: string - secretRef: - properties: - name: - type: string - optional: - type: boolean - type: object - type: object - type: array - image: + hostNetwork: + type: boolean + hostPID: + type: boolean + hostname: + type: string + imagePullSecrets: + items: + properties: + name: + type: string + type: object + type: array + initContainers: + items: + properties: + args: + items: type: string - imagePullPolicy: + type: array + command: + items: type: string - lifecycle: + type: array + env: + items: properties: - postStart: + name: + type: string + value: + type: string + valueFrom: properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - httpGet: + configMapKeyRef: properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: + key: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: + name: type: string + optional: + type: boolean required: - - port + - key type: object - tcpSocket: + fieldRef: properties: - host: + apiVersion: + type: string + fieldPath: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true required: - - port - type: object - type: object - preStop: - properties: - exec: - properties: - command: - items: - type: string - type: array + - fieldPath type: object - httpGet: + resourceFieldRef: properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: + containerName: type: string - port: + divisor: 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 - scheme: + resource: type: string required: - - port + - resource type: object - tcpSocket: + secretKeyRef: properties: - host: + key: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true + name: + type: string + optional: + type: boolean required: - - port + - key type: object type: object + required: + - name type: object - livenessProbe: + type: array + envFrom: + items: properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: + configMapRef: properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: + name: type: string - required: - - port + optional: + type: boolean type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: + prefix: + type: string + secretRef: properties: - host: + name: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port + optional: + type: boolean type: object - timeoutSeconds: - format: int32 - type: integer type: object - name: - type: string - ports: - items: + type: array + image: + type: string + imagePullPolicy: + type: string + lifecycle: + properties: + postStart: properties: - containerPort: - format: int32 - type: integer - hostIP: - type: string - hostPort: - format: int32 - type: integer - name: - type: string - protocol: - type: string - required: - - containerPort - type: object - type: array - readinessProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - resources: - properties: - 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 - 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 - type: object - type: object - securityContext: - properties: - allowPrivilegeEscalation: - type: boolean - capabilities: - properties: - add: - items: + exec: + properties: + command: + items: + type: string + type: array + type: object + httpGet: + properties: + host: type: string - type: array - drop: - items: + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: type: string - type: array - type: object - privileged: - type: boolean - procMount: - type: string - readOnlyRootFilesystem: - type: boolean - runAsGroup: - format: int64 - type: integer - runAsNonRoot: - type: boolean - runAsUser: - format: int64 - type: integer - seLinuxOptions: - properties: - level: - type: string - role: - type: string - type: - type: string - user: - type: string - type: object - windowsOptions: - properties: - gmsaCredentialSpec: - type: string - gmsaCredentialSpecName: - type: string - runAsUserName: - type: string - type: object - type: object - startupProbe: - properties: - exec: - properties: - command: - items: + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - stdin: - type: boolean - stdinOnce: - type: boolean - targetContainerName: - type: string - terminationMessagePath: - type: string - terminationMessagePolicy: - type: string - tty: - type: boolean - volumeDevices: - items: - properties: - devicePath: - type: string - name: - type: string - required: - - devicePath - - name - type: object - type: array - volumeMounts: - items: - properties: - mountPath: - type: string - mountPropagation: - type: string - name: - type: string - readOnly: - type: boolean - subPath: - type: string - subPathExpr: - type: string - required: - - mountPath - - name - type: object - type: array - workingDir: - type: string - required: - - name - type: object - - items: - properties: - args: - items: - type: string - type: array - command: - items: - type: string - type: array - env: - items: - properties: - name: - type: string - value: - type: string - valueFrom: + required: + - port + type: object + tcpSocket: properties: - configMapKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - secretKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port type: object - required: - - name type: object - type: array - envFrom: - items: + preStop: properties: - configMapRef: + exec: properties: - name: + command: + items: + type: string + type: array + type: object + httpGet: + properties: + host: type: string - optional: - type: boolean + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: + type: string + required: + - port type: object - prefix: - type: string - secretRef: + tcpSocket: properties: - name: + host: type: string - optional: - type: boolean + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port type: object type: object - type: array - image: - type: string - imagePullPolicy: - type: string - lifecycle: - properties: - postStart: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - httpGet: + type: object + livenessProbe: + properties: + exec: + properties: + command: + items: + type: string + type: array + type: object + failureThreshold: + format: int32 + type: integer + httpGet: + properties: + host: + type: string + httpHeaders: + items: properties: - host: + name: type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - type: object - preStop: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - tcpSocket: - properties: - host: + value: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true required: - - port + - name + - value type: object - type: object - type: object - livenessProbe: + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: + type: string + required: + - port + type: object + initialDelaySeconds: + format: int32 + type: integer + periodSeconds: + format: int32 + type: integer + successThreshold: + format: int32 + type: integer + tcpSocket: + properties: + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + timeoutSeconds: + format: int32 + type: integer + type: object + name: + type: string + ports: + items: properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: + containerPort: format: int32 type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: + hostIP: + type: string + hostPort: format: int32 type: integer + name: + type: string + protocol: + type: string + required: + - containerPort type: object - name: - type: string - ports: - items: + type: array + x-kubernetes-list-map-keys: + - containerPort + - protocol + x-kubernetes-list-type: map + readinessProbe: + properties: + exec: properties: - containerPort: - format: int32 - type: integer - hostIP: + command: + items: + type: string + type: array + type: object + failureThreshold: + format: int32 + type: integer + httpGet: + properties: + host: type: string - hostPort: - format: int32 - type: integer - name: + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: type: string - protocol: + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: type: string required: - - containerPort + - port type: object - type: array - readinessProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - resources: - properties: - 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 - type: object - requests: - additionalProperties: + initialDelaySeconds: + format: int32 + type: integer + periodSeconds: + format: int32 + type: integer + successThreshold: + format: int32 + type: integer + tcpSocket: + properties: + host: + type: string + port: 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 - type: object - type: object - securityContext: - properties: - allowPrivilegeEscalation: - type: boolean - capabilities: - properties: - add: - items: - type: string - type: array - drop: - items: - type: string - type: array - type: object - privileged: - type: boolean - procMount: - type: string - readOnlyRootFilesystem: - type: boolean - runAsGroup: - format: int64 - type: integer - runAsNonRoot: - type: boolean - runAsUser: - format: int64 - type: integer - seLinuxOptions: - properties: - level: - type: string - role: - type: string - type: - type: string - user: - type: string - type: object - windowsOptions: - properties: - gmsaCredentialSpec: - type: string - gmsaCredentialSpecName: - type: string - runAsUserName: - type: string - type: object - type: object - startupProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: + required: + - port + type: object + timeoutSeconds: + format: int32 + type: integer + type: object + resources: + properties: + 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 + 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 + type: object + type: object + securityContext: + properties: + allowPrivilegeEscalation: + type: boolean + capabilities: + properties: + add: + items: type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: + type: array + drop: + items: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - stdin: - type: boolean - stdinOnce: - type: boolean - targetContainerName: - type: string - terminationMessagePath: - type: string - terminationMessagePolicy: - type: string - tty: - type: boolean - volumeDevices: - items: + type: array + type: object + privileged: + type: boolean + procMount: + type: string + readOnlyRootFilesystem: + type: boolean + runAsGroup: + format: int64 + type: integer + runAsNonRoot: + type: boolean + runAsUser: + format: int64 + type: integer + seLinuxOptions: properties: - devicePath: + level: type: string - name: + role: + type: string + type: + type: string + user: type: string - required: - - devicePath - - name type: object - type: array - volumeMounts: - items: + windowsOptions: properties: - mountPath: + gmsaCredentialSpec: type: string - mountPropagation: + gmsaCredentialSpecName: type: string - name: + runAsUserName: type: string - readOnly: - type: boolean - subPath: + type: object + type: object + startupProbe: + properties: + exec: + properties: + command: + items: + type: string + type: array + type: object + failureThreshold: + format: int32 + type: integer + httpGet: + properties: + host: type: string - subPathExpr: + httpHeaders: + items: + properties: + name: + type: string + value: + type: string + required: + - name + - value + type: object + type: array + path: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + scheme: type: string required: - - mountPath - - name + - port type: object - type: array - workingDir: - type: string - required: - - name - type: object + initialDelaySeconds: + format: int32 + type: integer + periodSeconds: + format: int32 + type: integer + successThreshold: + format: int32 + type: integer + tcpSocket: + properties: + host: + type: string + port: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + required: + - port + type: object + timeoutSeconds: + format: int32 + type: integer + type: object + stdin: + type: boolean + stdinOnce: + type: boolean + terminationMessagePath: + type: string + terminationMessagePolicy: + type: string + tty: + type: boolean + volumeDevices: + items: + properties: + devicePath: + type: string + name: + type: string + required: + - devicePath + - name + type: object + type: array + volumeMounts: + items: + properties: + mountPath: + type: string + mountPropagation: + type: string + name: + type: string + readOnly: + type: boolean + subPath: + type: string + subPathExpr: + type: string + required: + - mountPath + - name + type: object + type: array + workingDir: + type: string + required: + - name + type: object type: array - hostAliases: - allOf: - - items: - properties: - hostnames: - items: - type: string - type: array - ip: - type: string - type: object - - items: - properties: - hostnames: - items: - type: string - type: array - ip: - type: string - type: object + logger: + properties: + mode: + enum: + - all + - request + - response + type: string + url: + type: string + type: object + maxReplicas: + type: integer + minReplicas: + type: integer + nodeName: + type: string + nodeSelector: + additionalProperties: + type: string + type: object + overhead: + 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 + type: object + preemptionPolicy: + type: string + priority: + format: int32 + type: integer + priorityClassName: + type: string + readinessGates: + items: + properties: + conditionType: + type: string + required: + - conditionType + type: object type: array - hostIPC: - type: boolean - hostNetwork: - type: boolean - hostPID: - type: boolean - hostname: + restartPolicy: type: string - imagePullSecrets: - allOf: - - items: + runtimeClassName: + type: string + schedulerName: + type: string + securityContext: + properties: + fsGroup: + format: int64 + type: integer + runAsGroup: + format: int64 + type: integer + runAsNonRoot: + type: boolean + runAsUser: + format: int64 + type: integer + seLinuxOptions: properties: - name: + level: type: string - type: object - - items: - properties: - name: + role: + type: string + type: + type: string + user: type: string type: object - type: array - initContainers: - allOf: - - items: - properties: - args: - items: + supplementalGroups: + items: + format: int64 + type: integer + type: array + sysctls: + items: + properties: + name: type: string - type: array - command: - items: + value: type: string - type: array - env: - items: - properties: - name: - type: string - value: - type: string - valueFrom: - properties: - configMapKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - secretKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - type: object - required: - - name - type: object - type: array - envFrom: - items: - properties: - configMapRef: - properties: - name: - type: string - optional: - type: boolean - type: object - prefix: - type: string - secretRef: - properties: - name: - type: string - optional: - type: boolean - type: object - type: object - type: array - image: + required: + - name + - value + type: object + type: array + windowsOptions: + properties: + gmsaCredentialSpec: type: string - imagePullPolicy: + gmsaCredentialSpecName: type: string - lifecycle: - properties: - postStart: + runAsUserName: + type: string + type: object + type: object + serviceAccount: + type: string + serviceAccountName: + type: string + shareProcessNamespace: + type: boolean + subdomain: + type: string + terminationGracePeriodSeconds: + format: int64 + type: integer + timeout: + format: int64 + type: integer + tolerations: + items: + properties: + effect: + type: string + key: + type: string + operator: + type: string + tolerationSeconds: + format: int64 + type: integer + value: + type: string + type: object + type: array + topologySpreadConstraints: + items: + properties: + labelSelector: + properties: + matchExpressions: + items: properties: - exec: + 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 + maxSkew: + format: int32 + type: integer + topologyKey: + type: string + whenUnsatisfiable: + type: string + required: + - maxSkew + - topologyKey + - whenUnsatisfiable + type: object + type: array + x-kubernetes-list-map-keys: + - topologyKey + - whenUnsatisfiable + x-kubernetes-list-type: map + volumes: + items: + properties: + awsElasticBlockStore: + properties: + fsType: + type: string + partition: + format: int32 + type: integer + readOnly: + type: boolean + volumeID: + type: string + required: + - volumeID + type: object + azureDisk: + properties: + cachingMode: + type: string + diskName: + type: string + diskURI: + type: string + fsType: + type: string + kind: + type: string + readOnly: + type: boolean + required: + - diskName + - diskURI + type: object + azureFile: + properties: + readOnly: + type: boolean + secretName: + type: string + shareName: + type: string + required: + - secretName + - shareName + type: object + cephfs: + properties: + monitors: + items: + type: string + type: array + path: + type: string + readOnly: + type: boolean + secretFile: + type: string + secretRef: + properties: + name: + type: string + type: object + user: + type: string + required: + - monitors + type: object + cinder: + properties: + fsType: + type: string + readOnly: + type: boolean + secretRef: + properties: + name: + type: string + type: object + volumeID: + type: string + required: + - volumeID + type: object + configMap: + properties: + defaultMode: + format: int32 + type: integer + items: + items: + properties: + key: + type: string + mode: + format: int32 + type: integer + path: + type: string + required: + - key + - path + type: object + type: array + name: + type: string + optional: + type: boolean + type: object + csi: + properties: + driver: + type: string + fsType: + type: string + nodePublishSecretRef: + properties: + name: + type: string + type: object + readOnly: + type: boolean + volumeAttributes: + additionalProperties: + type: string + type: object + required: + - driver + type: object + downwardAPI: + properties: + defaultMode: + format: int32 + type: integer + items: + items: + properties: + fieldRef: properties: - command: - items: - type: string - type: array + apiVersion: + type: string + fieldPath: + type: string + required: + - fieldPath type: object - httpGet: + mode: + format: int32 + type: integer + path: + type: string + resourceFieldRef: properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: + containerName: type: string - port: + divisor: 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 - scheme: + resource: type: string required: - - port - type: object - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port + - resource type: object + required: + - path type: object - preStop: + type: array + type: object + emptyDir: + properties: + medium: + type: string + sizeLimit: + 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 + type: object + fc: + properties: + fsType: + type: string + lun: + format: int32 + type: integer + readOnly: + type: boolean + targetWWNs: + items: + type: string + type: array + wwids: + items: + type: string + type: array + type: object + flexVolume: + properties: + driver: + type: string + fsType: + type: string + options: + additionalProperties: + type: string + type: object + readOnly: + type: boolean + secretRef: + properties: + name: + type: string + type: object + required: + - driver + type: object + flocker: + properties: + datasetName: + type: string + datasetUUID: + type: string + type: object + gcePersistentDisk: + properties: + fsType: + type: string + partition: + format: int32 + type: integer + pdName: + type: string + readOnly: + type: boolean + required: + - pdName + type: object + gitRepo: + properties: + directory: + type: string + repository: + type: string + revision: + type: string + required: + - repository + type: object + glusterfs: + properties: + endpoints: + type: string + path: + type: string + readOnly: + type: boolean + required: + - endpoints + - path + type: object + hostPath: + properties: + path: + type: string + type: + type: string + required: + - path + type: object + iscsi: + properties: + chapAuthDiscovery: + type: boolean + chapAuthSession: + type: boolean + fsType: + type: string + initiatorName: + type: string + iqn: + type: string + iscsiInterface: + type: string + lun: + format: int32 + type: integer + portals: + items: + type: string + type: array + readOnly: + type: boolean + secretRef: + properties: + name: + type: string + type: object + targetPortal: + type: string + required: + - iqn + - lun + - targetPortal + type: object + name: + type: string + nfs: + properties: + path: + type: string + readOnly: + type: boolean + server: + type: string + required: + - path + - server + type: object + persistentVolumeClaim: + properties: + claimName: + type: string + readOnly: + type: boolean + required: + - claimName + type: object + photonPersistentDisk: + properties: + fsType: + type: string + pdID: + type: string + required: + - pdID + type: object + portworxVolume: + properties: + fsType: + type: string + readOnly: + type: boolean + volumeID: + type: string + required: + - volumeID + type: object + projected: + properties: + defaultMode: + format: int32 + type: integer + sources: + items: properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - httpGet: + configMap: properties: - host: - type: string - httpHeaders: + items: items: properties: - name: + key: type: string - value: + mode: + format: int32 + type: integer + path: type: string required: - - name - - value + - key + - path type: object type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: + name: type: string - required: - - port + optional: + type: boolean type: object - tcpSocket: + downwardAPI: properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - type: object - type: object - livenessProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port + items: + items: + properties: + fieldRef: + properties: + apiVersion: + type: string + fieldPath: + type: string + required: + - fieldPath + type: object + mode: + format: int32 + type: integer + path: + type: string + resourceFieldRef: + properties: + containerName: + type: string + divisor: + 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 + resource: + type: string + required: + - resource + type: object + required: + - path + type: object + type: array + type: object + secret: + properties: + items: + items: + properties: + key: + type: string + mode: + format: int32 + type: integer + path: + type: string + required: + - key + - path + type: object + type: array + name: + type: string + optional: + type: boolean + type: object + serviceAccountToken: + properties: + audience: + type: string + expirationSeconds: + format: int64 + type: integer + path: + type: string + required: + - path + type: object type: object - timeoutSeconds: - format: int32 - type: integer - type: object - name: - type: string - ports: - items: + type: array + required: + - sources + type: object + quobyte: + properties: + group: + type: string + readOnly: + type: boolean + registry: + type: string + tenant: + type: string + user: + type: string + volume: + type: string + required: + - registry + - volume + type: object + rbd: + properties: + fsType: + type: string + image: + type: string + keyring: + type: string + monitors: + items: + type: string + type: array + pool: + type: string + readOnly: + type: boolean + secretRef: properties: - containerPort: - format: int32 - type: integer - hostIP: - type: string - hostPort: - format: int32 - type: integer name: type: string - protocol: + type: object + user: + type: string + required: + - image + - monitors + type: object + scaleIO: + properties: + fsType: + type: string + gateway: + type: string + protectionDomain: + type: string + readOnly: + type: boolean + secretRef: + properties: + name: type: string - required: - - containerPort type: object - type: array - x-kubernetes-list-map-keys: - - containerPort - - protocol - x-kubernetes-list-type: map - readinessProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: + sslEnabled: + type: boolean + storageMode: + type: string + storagePool: + type: string + system: + type: string + volumeName: + type: string + required: + - gateway + - secretRef + - system + type: object + secret: + properties: + defaultMode: + format: int32 + type: integer + items: + items: properties: - host: + key: type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array + mode: + format: int32 + type: integer path: type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string required: - - port + - key + - path type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - resources: - properties: - 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 - 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 - type: object - type: object - securityContext: - properties: - allowPrivilegeEscalation: - type: boolean - capabilities: - properties: - add: - items: - type: string - type: array - drop: - items: - type: string - type: array - type: object - privileged: - type: boolean - procMount: - type: string - readOnlyRootFilesystem: - type: boolean - runAsGroup: - format: int64 - type: integer - runAsNonRoot: - type: boolean - runAsUser: - format: int64 - type: integer - seLinuxOptions: - properties: - level: - type: string - role: - type: string - type: - type: string - user: - type: string - type: object - windowsOptions: - properties: - gmsaCredentialSpec: - type: string - gmsaCredentialSpecName: - type: string - runAsUserName: - type: string - type: object - type: object - startupProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - stdin: - type: boolean - stdinOnce: - type: boolean - terminationMessagePath: - type: string - terminationMessagePolicy: - type: string - tty: - type: boolean - volumeDevices: - items: - properties: - devicePath: - type: string - name: - type: string - required: - - devicePath - - name - type: object - type: array - volumeMounts: - items: - properties: - mountPath: - type: string - mountPropagation: - type: string - name: - type: string - readOnly: - type: boolean - subPath: - type: string - subPathExpr: - type: string - required: - - mountPath - - name - type: object - type: array - workingDir: - type: string - required: - - name - type: object - - items: - properties: - args: - items: + type: array + optional: + type: boolean + secretName: type: string - type: array - command: - items: + type: object + storageos: + properties: + fsType: type: string - type: array - env: - items: + readOnly: + type: boolean + secretRef: properties: name: type: string - value: - type: string - valueFrom: - properties: - configMapKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - secretKeyRef: - properties: - key: - type: string - name: - type: string - optional: - type: boolean - required: - - key - type: object - type: object - required: - - name - type: object - type: array - envFrom: - items: - properties: - configMapRef: - properties: - name: - type: string - optional: - type: boolean - type: object - prefix: - type: string - secretRef: - properties: - name: - type: string - optional: - type: boolean - type: object type: object - type: array - image: - type: string - imagePullPolicy: - type: string - lifecycle: - properties: - postStart: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - type: object - preStop: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - type: object - type: object - livenessProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - name: - type: string - ports: - items: - properties: - containerPort: - format: int32 - type: integer - hostIP: - type: string - hostPort: - format: int32 - type: integer - name: - type: string - protocol: - type: string - required: - - containerPort - type: object - type: array - x-kubernetes-list-map-keys: - - containerPort - - protocol - x-kubernetes-list-type: map - readinessProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - resources: - properties: - 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 - 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 - type: object - type: object - securityContext: - properties: - allowPrivilegeEscalation: - type: boolean - capabilities: - properties: - add: - items: - type: string - type: array - drop: - items: - type: string - type: array - type: object - privileged: - type: boolean - procMount: - type: string - readOnlyRootFilesystem: - type: boolean - runAsGroup: - format: int64 - type: integer - runAsNonRoot: - type: boolean - runAsUser: - format: int64 - type: integer - seLinuxOptions: - properties: - level: - type: string - role: - type: string - type: - type: string - user: - type: string - type: object - windowsOptions: - properties: - gmsaCredentialSpec: - type: string - gmsaCredentialSpecName: - type: string - runAsUserName: - type: string - type: object - type: object - startupProbe: - properties: - exec: - properties: - command: - items: - type: string - type: array - type: object - failureThreshold: - format: int32 - type: integer - httpGet: - properties: - host: - type: string - httpHeaders: - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - path: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - scheme: - type: string - required: - - port - type: object - initialDelaySeconds: - format: int32 - type: integer - periodSeconds: - format: int32 - type: integer - successThreshold: - format: int32 - type: integer - tcpSocket: - properties: - host: - type: string - port: - anyOf: - - type: integer - - type: string - x-kubernetes-int-or-string: true - required: - - port - type: object - timeoutSeconds: - format: int32 - type: integer - type: object - stdin: - type: boolean - stdinOnce: - type: boolean - terminationMessagePath: - type: string - terminationMessagePolicy: - type: string - tty: - type: boolean - volumeDevices: - items: - properties: - devicePath: - type: string - name: - type: string - required: - - devicePath - - name - type: object - type: array - volumeMounts: - items: - properties: - mountPath: - type: string - mountPropagation: - type: string - name: - type: string - readOnly: - type: boolean - subPath: - type: string - subPathExpr: - type: string - required: - - mountPath - - name - type: object - type: array - workingDir: - type: string - required: - - name - type: object - type: array - logger: - properties: - mode: - enum: - - all - - request - - response - type: string - url: - type: string - type: object - maxReplicas: - type: integer - minReplicas: - type: integer - nodeName: - type: string - nodeSelector: - additionalProperties: - type: string - type: object - overhead: - additionalProperties: - allOf: - - anyOf: - - type: integer - - type: string - - 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 - type: object - preemptionPolicy: - type: string - priority: - format: int32 - type: integer - priorityClassName: - type: string - readinessGates: - allOf: - - items: - properties: - conditionType: - type: string - required: - - conditionType - type: object - - items: - properties: - conditionType: - type: string - required: - - conditionType - type: object - type: array - restartPolicy: - type: string - runtimeClassName: - type: string - schedulerName: - type: string - securityContext: - properties: - fsGroup: - format: int64 - type: integer - runAsGroup: - format: int64 - type: integer - runAsNonRoot: - type: boolean - runAsUser: - format: int64 - type: integer - seLinuxOptions: - properties: - level: - type: string - role: - type: string - type: - type: string - user: - type: string - type: object - supplementalGroups: - allOf: - - items: - format: int64 - type: integer - - items: - format: int64 - type: integer - type: array - sysctls: - allOf: - - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - - items: - properties: - name: - type: string - value: - type: string - required: - - name - - value - type: object - type: array - windowsOptions: - properties: - gmsaCredentialSpec: - type: string - gmsaCredentialSpecName: - type: string - runAsUserName: - type: string - type: object - type: object - serviceAccount: - type: string - serviceAccountName: - type: string - shareProcessNamespace: - type: boolean - subdomain: - type: string - terminationGracePeriodSeconds: - format: int64 - type: integer - timeout: - format: int64 - type: integer - tolerations: - allOf: - - items: - properties: - effect: - type: string - key: - type: string - operator: - type: string - tolerationSeconds: - format: int64 - type: integer - value: - type: string - type: object - - items: - properties: - effect: - type: string - key: - type: string - operator: - type: string - tolerationSeconds: - format: int64 - type: integer - value: - type: string - type: object - type: array - topologySpreadConstraints: - allOf: - - 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 - maxSkew: - format: int32 - type: integer - topologyKey: - type: string - whenUnsatisfiable: - type: string - required: - - maxSkew - - topologyKey - - whenUnsatisfiable - type: object - x-kubernetes-list-map-keys: - - topologyKey - - whenUnsatisfiable - x-kubernetes-list-type: map - - 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 - maxSkew: - format: int32 - type: integer - topologyKey: - type: string - whenUnsatisfiable: - type: string - required: - - maxSkew - - topologyKey - - whenUnsatisfiable - type: object - x-kubernetes-list-map-keys: - - topologyKey - - whenUnsatisfiable - x-kubernetes-list-type: map - type: array - volumes: - allOf: - - items: - properties: - awsElasticBlockStore: - properties: - fsType: - type: string - partition: - format: int32 - type: integer - readOnly: - type: boolean - volumeID: - type: string - required: - - volumeID - type: object - azureDisk: - properties: - cachingMode: - type: string - diskName: - type: string - diskURI: - type: string - fsType: - type: string - kind: - type: string - readOnly: - type: boolean - required: - - diskName - - diskURI - type: object - azureFile: - properties: - readOnly: - type: boolean - secretName: - type: string - shareName: - type: string - required: - - secretName - - shareName - type: object - cephfs: - properties: - monitors: - items: - type: string - type: array - path: - type: string - readOnly: - type: boolean - secretFile: - type: string - secretRef: - properties: - name: - type: string - type: object - user: - type: string - required: - - monitors - type: object - cinder: - properties: - fsType: - type: string - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - volumeID: - type: string - required: - - volumeID - type: object - configMap: - properties: - defaultMode: - format: int32 - type: integer - items: - items: - properties: - key: - type: string - mode: - format: int32 - type: integer - path: - type: string - required: - - key - - path - type: object - type: array - name: - type: string - optional: - type: boolean - type: object - csi: - properties: - driver: - type: string - fsType: - type: string - nodePublishSecretRef: - properties: - name: - type: string - type: object - readOnly: - type: boolean - volumeAttributes: - additionalProperties: - type: string - type: object - required: - - driver - type: object - downwardAPI: - properties: - defaultMode: - format: int32 - type: integer - items: - items: - properties: - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - mode: - format: int32 - type: integer - path: - type: string - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - required: - - path - type: object - type: array - type: object - emptyDir: - properties: - medium: - type: string - sizeLimit: - 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 - type: object - fc: - properties: - fsType: - type: string - lun: - format: int32 - type: integer - readOnly: - type: boolean - targetWWNs: - items: - type: string - type: array - wwids: - items: - type: string - type: array - type: object - flexVolume: - properties: - driver: - type: string - fsType: - type: string - options: - additionalProperties: - type: string - type: object - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - required: - - driver - type: object - flocker: - properties: - datasetName: - type: string - datasetUUID: - type: string - type: object - gcePersistentDisk: - properties: - fsType: - type: string - partition: - format: int32 - type: integer - pdName: - type: string - readOnly: - type: boolean - required: - - pdName - type: object - gitRepo: - properties: - directory: - type: string - repository: - type: string - revision: - type: string - required: - - repository - type: object - glusterfs: - properties: - endpoints: - type: string - path: - type: string - readOnly: - type: boolean - required: - - endpoints - - path - type: object - hostPath: - properties: - path: - type: string - type: - type: string - required: - - path - type: object - iscsi: - properties: - chapAuthDiscovery: - type: boolean - chapAuthSession: - type: boolean - fsType: - type: string - initiatorName: - type: string - iqn: - type: string - iscsiInterface: - type: string - lun: - format: int32 - type: integer - portals: - items: - type: string - type: array - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - targetPortal: - type: string - required: - - iqn - - lun - - targetPortal - type: object - name: - type: string - nfs: - properties: - path: - type: string - readOnly: - type: boolean - server: - type: string - required: - - path - - server - type: object - persistentVolumeClaim: - properties: - claimName: - type: string - readOnly: - type: boolean - required: - - claimName - type: object - photonPersistentDisk: - properties: - fsType: - type: string - pdID: - type: string - required: - - pdID - type: object - portworxVolume: - properties: - fsType: - type: string - readOnly: - type: boolean - volumeID: - type: string - required: - - volumeID - type: object - projected: - properties: - defaultMode: - format: int32 - type: integer - sources: - items: - properties: - configMap: - properties: - items: - items: - properties: - key: - type: string - mode: - format: int32 - type: integer - path: - type: string - required: - - key - - path - type: object - type: array - name: - type: string - optional: - type: boolean - type: object - downwardAPI: - properties: - items: - items: - properties: - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - mode: - format: int32 - type: integer - path: - type: string - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - required: - - path - type: object - type: array - type: object - secret: - properties: - items: - items: - properties: - key: - type: string - mode: - format: int32 - type: integer - path: - type: string - required: - - key - - path - type: object - type: array - name: - type: string - optional: - type: boolean - type: object - serviceAccountToken: - properties: - audience: - type: string - expirationSeconds: - format: int64 - type: integer - path: - type: string - required: - - path - type: object - type: object - type: array - required: - - sources - type: object - quobyte: - properties: - group: - type: string - readOnly: - type: boolean - registry: - type: string - tenant: - type: string - user: - type: string - volume: - type: string - required: - - registry - - volume - type: object - rbd: - properties: - fsType: - type: string - image: - type: string - keyring: - type: string - monitors: - items: - type: string - type: array - pool: - type: string - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - user: - type: string - required: - - image - - monitors - type: object - scaleIO: - properties: - fsType: - type: string - gateway: - type: string - protectionDomain: - type: string - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - sslEnabled: - type: boolean - storageMode: - type: string - storagePool: - type: string - system: - type: string - volumeName: - type: string - required: - - gateway - - secretRef - - system - type: object - secret: - properties: - defaultMode: - format: int32 - type: integer - items: - items: - properties: - key: - type: string - mode: - format: int32 - type: integer - path: - type: string - required: - - key - - path - type: object - type: array - optional: - type: boolean - secretName: - type: string - type: object - storageos: - properties: - fsType: - type: string - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - volumeName: - type: string - volumeNamespace: - type: string - type: object - vsphereVolume: - properties: - fsType: - type: string - storagePolicyID: - type: string - storagePolicyName: - type: string - volumePath: - type: string - required: - - volumePath - type: object - required: - - name - type: object - - items: - properties: - awsElasticBlockStore: - properties: - fsType: - type: string - partition: - format: int32 - type: integer - readOnly: - type: boolean - volumeID: - type: string - required: - - volumeID - type: object - azureDisk: - properties: - cachingMode: - type: string - diskName: - type: string - diskURI: - type: string - fsType: - type: string - kind: - type: string - readOnly: - type: boolean - required: - - diskName - - diskURI - type: object - azureFile: - properties: - readOnly: - type: boolean - secretName: - type: string - shareName: - type: string - required: - - secretName - - shareName - type: object - cephfs: - properties: - monitors: - items: - type: string - type: array - path: - type: string - readOnly: - type: boolean - secretFile: - type: string - secretRef: - properties: - name: - type: string - type: object - user: - type: string - required: - - monitors - type: object - cinder: - properties: - fsType: - type: string - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - volumeID: - type: string - required: - - volumeID - type: object - configMap: - properties: - defaultMode: - format: int32 - type: integer - items: - items: - properties: - key: - type: string - mode: - format: int32 - type: integer - path: - type: string - required: - - key - - path - type: object - type: array - name: - type: string - optional: - type: boolean - type: object - csi: - properties: - driver: - type: string - fsType: - type: string - nodePublishSecretRef: - properties: - name: - type: string - type: object - readOnly: - type: boolean - volumeAttributes: - additionalProperties: - type: string - type: object - required: - - driver - type: object - downwardAPI: - properties: - defaultMode: - format: int32 - type: integer - items: - items: - properties: - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - mode: - format: int32 - type: integer - path: - type: string - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - required: - - path - type: object - type: array - type: object - emptyDir: - properties: - medium: - type: string - sizeLimit: - 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 - type: object - fc: - properties: - fsType: - type: string - lun: - format: int32 - type: integer - readOnly: - type: boolean - targetWWNs: - items: - type: string - type: array - wwids: - items: - type: string - type: array - type: object - flexVolume: - properties: - driver: - type: string - fsType: - type: string - options: - additionalProperties: - type: string - type: object - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - required: - - driver - type: object - flocker: - properties: - datasetName: - type: string - datasetUUID: - type: string - type: object - gcePersistentDisk: - properties: - fsType: - type: string - partition: - format: int32 - type: integer - pdName: - type: string - readOnly: - type: boolean - required: - - pdName - type: object - gitRepo: - properties: - directory: - type: string - repository: - type: string - revision: - type: string - required: - - repository - type: object - glusterfs: - properties: - endpoints: - type: string - path: - type: string - readOnly: - type: boolean - required: - - endpoints - - path - type: object - hostPath: - properties: - path: - type: string - type: - type: string - required: - - path - type: object - iscsi: - properties: - chapAuthDiscovery: - type: boolean - chapAuthSession: - type: boolean - fsType: - type: string - initiatorName: - type: string - iqn: - type: string - iscsiInterface: - type: string - lun: - format: int32 - type: integer - portals: - items: - type: string - type: array - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - targetPortal: - type: string - required: - - iqn - - lun - - targetPortal - type: object - name: - type: string - nfs: - properties: - path: - type: string - readOnly: - type: boolean - server: - type: string - required: - - path - - server - type: object - persistentVolumeClaim: - properties: - claimName: - type: string - readOnly: - type: boolean - required: - - claimName - type: object - photonPersistentDisk: - properties: - fsType: - type: string - pdID: - type: string - required: - - pdID - type: object - portworxVolume: - properties: - fsType: - type: string - readOnly: - type: boolean - volumeID: - type: string - required: - - volumeID - type: object - projected: - properties: - defaultMode: - format: int32 - type: integer - sources: - items: - properties: - configMap: - properties: - items: - items: - properties: - key: - type: string - mode: - format: int32 - type: integer - path: - type: string - required: - - key - - path - type: object - type: array - name: - type: string - optional: - type: boolean - type: object - downwardAPI: - properties: - items: - items: - properties: - fieldRef: - properties: - apiVersion: - type: string - fieldPath: - type: string - required: - - fieldPath - type: object - mode: - format: int32 - type: integer - path: - type: string - resourceFieldRef: - properties: - containerName: - type: string - divisor: - 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 - resource: - type: string - required: - - resource - type: object - required: - - path - type: object - type: array - type: object - secret: - properties: - items: - items: - properties: - key: - type: string - mode: - format: int32 - type: integer - path: - type: string - required: - - key - - path - type: object - type: array - name: - type: string - optional: - type: boolean - type: object - serviceAccountToken: - properties: - audience: - type: string - expirationSeconds: - format: int64 - type: integer - path: - type: string - required: - - path - type: object - type: object - type: array - required: - - sources - type: object - quobyte: - properties: - group: - type: string - readOnly: - type: boolean - registry: - type: string - tenant: - type: string - user: - type: string - volume: - type: string - required: - - registry - - volume - type: object - rbd: - properties: - fsType: - type: string - image: - type: string - keyring: - type: string - monitors: - items: - type: string - type: array - pool: - type: string - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - user: - type: string - required: - - image - - monitors - type: object - scaleIO: - properties: - fsType: - type: string - gateway: - type: string - protectionDomain: - type: string - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - sslEnabled: - type: boolean - storageMode: - type: string - storagePool: - type: string - system: - type: string - volumeName: - type: string - required: - - gateway - - secretRef - - system - type: object - secret: - properties: - defaultMode: - format: int32 - type: integer - items: - items: - properties: - key: - type: string - mode: - format: int32 - type: integer - path: - type: string - required: - - key - - path - type: object - type: array - optional: - type: boolean - secretName: - type: string - type: object - storageos: - properties: - fsType: - type: string - readOnly: - type: boolean - secretRef: - properties: - name: - type: string - type: object - volumeName: - type: string - volumeNamespace: - type: string - type: object - vsphereVolume: - properties: - fsType: - type: string - storagePolicyID: - type: string - storagePolicyName: - type: string - volumePath: - type: string - required: - - volumePath - type: object - required: - - name - type: object + volumeName: + type: string + volumeNamespace: + type: string + type: object + vsphereVolume: + properties: + fsType: + type: string + storagePolicyID: + type: string + storagePolicyName: + type: string + volumePath: + type: string + required: + - volumePath + type: object + required: + - name + type: object type: array - required: - - containers type: object predictor: properties: diff --git a/pkg/apis/serving/v1beta1/explainer.go b/pkg/apis/serving/v1beta1/explainer.go index 08c557fca7..72460f1bd3 100644 --- a/pkg/apis/serving/v1beta1/explainer.go +++ b/pkg/apis/serving/v1beta1/explainer.go @@ -23,8 +23,6 @@ type ExplainerSpec struct { Alibi *AlibiExplainerSpec `json:"alibi,omitempty"` // Spec for AIX explainer AIX *AIXExplainerSpec `json:"aix,omitempty"` - // Pass through Pod fields or specify a custom container spec - *CustomExplainer `json:",inline"` // This spec is dual purpose. // 1) Users may choose to provide a full PodSpec for their custom explainer. // The field PodSpec.Containers is mutually exclusive with other explainers (i.e. Alibi). diff --git a/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go b/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go index f0ee883d3f..d64313b3f5 100644 --- a/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go +++ b/pkg/apis/serving/v1beta1/zz_generated.deepcopy.go @@ -249,11 +249,6 @@ func (in *ExplainerSpec) DeepCopyInto(out *ExplainerSpec) { *out = new(AIXExplainerSpec) (*in).DeepCopyInto(*out) } - if in.CustomExplainer != nil { - in, out := &in.CustomExplainer, &out.CustomExplainer - *out = new(CustomExplainer) - (*in).DeepCopyInto(*out) - } in.PodSpec.DeepCopyInto(&out.PodSpec) in.ComponentExtensionSpec.DeepCopyInto(&out.ComponentExtensionSpec) } From 08995e764c765bb684c22cf7a62a10aac91f5ea2 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Tue, 22 Sep 2020 13:45:50 -0700 Subject: [PATCH 23/32] fix empty uri for aix framework --- .../aix/mnist/aix-explainer-v1beta1.yaml | 19 +++++++++++++++++++ .../v1alpha2/inferenceservice_conversion.go | 9 +++++++++ pkg/apis/serving/v1beta1/explainer_aix360.go | 3 +++ 3 files changed, 31 insertions(+) create mode 100644 docs/samples/explanation/aix/mnist/aix-explainer-v1beta1.yaml diff --git a/docs/samples/explanation/aix/mnist/aix-explainer-v1beta1.yaml b/docs/samples/explanation/aix/mnist/aix-explainer-v1beta1.yaml new file mode 100644 index 0000000000..e78ff72508 --- /dev/null +++ b/docs/samples/explanation/aix/mnist/aix-explainer-v1beta1.yaml @@ -0,0 +1,19 @@ +apiVersion: "serving.kubeflow.org/v1beta1" +kind: "InferenceService" +metadata: + name: "aix-explainer" + namespace: default +spec: + predictor: + containers: + - name: predictor + image: aipipeline/rf-predictor:0.4.0 + command: ["python", "-m", "rfserver", "--model_name", "aix-explainer"] + imagePullPolicy: Always + explainer: + aix: + type: LimeImages + config: + num_samples: "100" + top_labels: "10" + min_weight: "0.01" diff --git a/pkg/apis/serving/v1alpha2/inferenceservice_conversion.go b/pkg/apis/serving/v1alpha2/inferenceservice_conversion.go index 7b2ef1e50a..f53595e4d5 100644 --- a/pkg/apis/serving/v1alpha2/inferenceservice_conversion.go +++ b/pkg/apis/serving/v1alpha2/inferenceservice_conversion.go @@ -289,6 +289,15 @@ func (dst *InferenceService) ConvertFrom(srcRaw conversion.Hub) error { Resources: src.Spec.Explainer.Alibi.Resources, }, } + } else if src.Spec.Explainer.AIX != nil { + dst.Spec.Default.Explainer = &ExplainerSpec{ + AIX: &AIXExplainerSpec{ + Type: AIXExplainerType(src.Spec.Explainer.AIX.Type), + StorageURI: src.Spec.Explainer.AIX.StorageURI, + RuntimeVersion: *src.Spec.Explainer.AIX.RuntimeVersion, + Resources: src.Spec.Explainer.AIX.Resources, + }, + } } else if len(src.Spec.Explainer.PodSpec.Containers) != 0 { dst.Spec.Default.Explainer = &ExplainerSpec{ Custom: &CustomSpec{ diff --git a/pkg/apis/serving/v1beta1/explainer_aix360.go b/pkg/apis/serving/v1beta1/explainer_aix360.go index 2c47cb886d..4776f18dae 100644 --- a/pkg/apis/serving/v1beta1/explainer_aix360.go +++ b/pkg/apis/serving/v1beta1/explainer_aix360.go @@ -37,6 +37,9 @@ type AIXExplainerSpec struct { var _ ComponentImplementation = &AIXExplainerSpec{} func (s *AIXExplainerSpec) GetStorageUri() *string { + if s.StorageURI == "" { + return nil + } return &s.StorageURI } From 62b53663deeb1aafdfc9229f9393089939c63099 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Tue, 22 Sep 2020 13:54:51 -0700 Subject: [PATCH 24/32] remove testing logs --- log.txt | 29714 ------------------------------------------------------ 1 file changed, 29714 deletions(-) delete mode 100644 log.txt diff --git a/log.txt b/log.txt deleted file mode 100644 index fc791baece..0000000000 --- a/log.txt +++ /dev/null @@ -1,29714 +0,0 @@ -go fmt ./pkg/... ./cmd/... -go vet ./pkg/... ./cmd/... -/Users/tommyli/go/bin/controller-gen "crd:maxDescLen=0" paths=./pkg/apis/serving/... output:crd:dir=config/crd -/Users/tommyli/go/bin/controller-gen rbac:roleName=kfserving-manager-role paths=./pkg/controller/... output:rbac:artifacts:config=config/rbac -/Users/tommyli/go/bin/controller-gen object:headerFile="hack/boilerplate.go.txt" paths=./pkg/apis/serving/v1alpha2 -/Users/tommyli/go/bin/controller-gen object:headerFile="hack/boilerplate.go.txt" paths=./pkg/apis/serving/v1beta1 -#TODO Remove this until new controller-tools is released -perl -pi -e 's/storedVersions: null/storedVersions: []/g' config/crd/serving.kubeflow.org_inferenceservices.yaml -perl -pi -e 's/conditions: null/conditions: []/g' config/crd/serving.kubeflow.org_inferenceservices.yaml -perl -pi -e 's/Any/string/g' config/crd/serving.kubeflow.org_inferenceservices.yaml -perl -pi -e 's/storedVersions: null/storedVersions: []/g' config/crd/serving.kubeflow.org_trainedmodels.yaml -perl -pi -e 's/conditions: null/conditions: []/g' config/crd/serving.kubeflow.org_trainedmodels.yaml -perl -pi -e 's/Any/string/g' config/crd/serving.kubeflow.org_trainedmodels.yaml -#TODO v1beta1 crd openAPIV3Schema is too big and kubectl client side apply takes long time to do diffs, need to use k8s 1.18's server side apply -#https://kubernetes.io/blog/2020/04/01/kubernetes-1.18-feature-server-side-apply-beta-2/#what-is-server-side-apply -#remove the required property on framework as name field needs to be optional -yq d -i config/crd/serving.kubeflow.org_inferenceservices.yaml 'spec.versions[1].schema.openAPIV3Schema.properties.spec.properties.*.properties.*.required' -#knative does not allow setting port on liveness or readiness probe -yq d -i config/crd/serving.kubeflow.org_inferenceservices.yaml 'spec.versions[1].schema.openAPIV3Schema.properties.spec.properties.*.properties.*.properties.readinessProbe.properties.httpGet.required' -yq d -i config/crd/serving.kubeflow.org_inferenceservices.yaml 'spec.versions[1].schema.openAPIV3Schema.properties.spec.properties.*.properties.*.properties.livenessProbe.properties.httpGet.required' -yq d -i config/crd/serving.kubeflow.org_inferenceservices.yaml 'spec.versions[1].schema.openAPIV3Schema.properties.spec.properties.*.properties.*.properties.readinessProbe.properties.tcpSocket.required' -yq d -i config/crd/serving.kubeflow.org_inferenceservices.yaml 'spec.versions[1].schema.openAPIV3Schema.properties.spec.properties.*.properties.*.properties.livenessProbe.properties.tcpSocket.required' -Add /usr/local/kubebuilder/bin/ to your PATH!! -go test ./pkg/... ./cmd/... -coverprofile coverage.out -? github.com/kubeflow/kfserving/pkg/agent [no test files] -? github.com/kubeflow/kfserving/pkg/agent/storage [no test files] -? github.com/kubeflow/kfserving/pkg/apis [no test files] -F0921 16:48:21.307100 13083 v1alpha2_suite_test.go:64] CustomResourceDefinition.apiextensions.k8s.io "inferenceservices.serving.kubeflow.org" is invalid: [spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items: Required value: must be specified] -FAIL github.com/kubeflow/kfserving/pkg/apis/serving/v1alpha2 25.091s -ok github.com/kubeflow/kfserving/pkg/apis/serving/v1beta1 1.720s coverage: 44.6% of statements -ok github.com/kubeflow/kfserving/pkg/batcher 0.673s coverage: 0.0% of statements -? github.com/kubeflow/kfserving/pkg/batcher/controllers [no test files] -? github.com/kubeflow/kfserving/pkg/batcher/routers [no test files] -? github.com/kubeflow/kfserving/pkg/client/clientset/versioned [no test files] -? github.com/kubeflow/kfserving/pkg/client/clientset/versioned/fake [no test files] -? github.com/kubeflow/kfserving/pkg/client/clientset/versioned/scheme [no test files] -? github.com/kubeflow/kfserving/pkg/client/clientset/versioned/typed/serving/v1beta1 [no test files] -? github.com/kubeflow/kfserving/pkg/client/clientset/versioned/typed/serving/v1beta1/fake [no test files] -? github.com/kubeflow/kfserving/pkg/client/informers/externalversions [no test files] -? github.com/kubeflow/kfserving/pkg/client/informers/externalversions/internalinterfaces [no test files] -? github.com/kubeflow/kfserving/pkg/client/informers/externalversions/serving [no test files] -? github.com/kubeflow/kfserving/pkg/client/informers/externalversions/serving/v1beta1 [no test files] -? github.com/kubeflow/kfserving/pkg/client/listers/serving/v1beta1 [no test files] -? github.com/kubeflow/kfserving/pkg/constants [no test files] -Running Suite: v1alpha2 InferenceService Controller Suite -========================================================= -Random Seed: 1600732079 -Will run 6 of 6 specs - -STEP: bootstrapping test environment -2020-09-21T16:47:59.911-0700 DEBUG controller-runtime.test-env starting control plane {"api server flags": ["--advertise-address=127.0.0.1", "--etcd-servers={{ if .EtcdURL }}{{ .EtcdURL.String }}{{ end }}", "--cert-dir={{ .CertDir }}", "--insecure-port={{ if .URL }}{{ .URL.Port }}{{ end }}", "--insecure-bind-address={{ if .URL }}{{ .URL.Hostname }}{{ end }}", "--secure-port={{ if .SecurePort }}{{ .SecurePort }}{{ end }}", "--admission-control=AlwaysAdmit", "--service-cluster-ip-range=10.0.0.0/24"]} -2020-09-21T16:48:19.611-0700 DEBUG controller-runtime.test-env installing CRDs -2020-09-21T16:48:19.611-0700 DEBUG controller-runtime.test-env reading CRDs from path {"path": "../../../../config/crd"} -2020-09-21T16:48:19.613-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "kustomization.yaml"} -2020-09-21T16:48:19.966-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "serving.kubeflow.org_inferenceservices.yaml"} -2020-09-21T16:48:19.968-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "serving.kubeflow.org_trainedmodels.yaml"} -2020-09-21T16:48:19.968-0700 DEBUG controller-runtime.test-env reading CRDs from path {"path": "../../../../test/crds"} -2020-09-21T16:48:19.969-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "istio_virtualservice.yaml"} -2020-09-21T16:48:19.969-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "knative_configuration.yaml"} -2020-09-21T16:48:19.970-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "knative_route.yaml"} -2020-09-21T16:48:19.996-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "knative_service.yaml"} -2020-09-21T16:48:19.996-0700 DEBUG controller-runtime.test-env installing CRD {"crd": "inferenceservices.serving.kubeflow.org"} -Failure [21.611 seconds] -[BeforeSuite] BeforeSuite  -/Users/tommyli/go/src/github.com/kubeflow/kfserving/pkg/controller/v1alpha2/inferenceservice/suite_test.go:47 - - Unexpected error: - <*errors.StatusError | 0xc0004686e0>: { - ErrStatus: { - TypeMeta: {Kind: "", APIVersion: ""}, - ListMeta: { - SelfLink: "", - ResourceVersion: "", - Continue: "", - RemainingItemCount: nil, - }, - Status: "Failure", - Message: "CustomResourceDefinition.apiextensions.k8s.io \"inferenceservices.serving.kubeflow.org\" is invalid: [spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items: Required value: must be specified]", - Reason: "Invalid", - Details: { - Name: "inferenceservices.serving.kubeflow.org", - Group: "apiextensions.k8s.io", - Kind: "CustomResourceDefinition", - UID: "", - Causes: [ - { - Type: "FieldValueRequired", - Message: "Required value: must be array if x-kubernetes-list-type is specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be array if x-kubernetes-list-type is specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items", - }, - ], - RetryAfterSeconds: 0, - }, - Code: 422, - }, - } - CustomResourceDefinition.apiextensions.k8s.io "inferenceservices.serving.kubeflow.org" is invalid: [spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items: Required value: must be specified] - occurred - - /Users/tommyli/go/src/github.com/kubeflow/kfserving/pkg/controller/v1alpha2/inferenceservice/suite_test.go:53 ------------------------------- - - -Ran 6 of 0 Specs in 21.787 seconds -FAIL! -- 0 Passed | 6 Failed | 0 Pending | 0 Skipped ---- FAIL: TestV1alpha2Controller (21.79s) -FAIL -coverage: 0.0% of statements -FAIL github.com/kubeflow/kfserving/pkg/controller/v1alpha2/inferenceservice 24.487s -? github.com/kubeflow/kfserving/pkg/controller/v1alpha2/inferenceservice/reconcilers/istio [no test files] -F0921 16:48:21.373257 13087 suite_test.go:34] CustomResourceDefinition.apiextensions.k8s.io "inferenceservices.serving.kubeflow.org" is invalid: [spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items: Required value: must be specified] -FAIL github.com/kubeflow/kfserving/pkg/controller/v1alpha2/inferenceservice/reconcilers/knative 24.434s -ok github.com/kubeflow/kfserving/pkg/controller/v1alpha2/inferenceservice/resources/istio 2.115s coverage: 83.3% of statements -ok github.com/kubeflow/kfserving/pkg/controller/v1alpha2/inferenceservice/resources/knative 25.698s coverage: 49.2% of statements -Running Suite: v1beta1 Controller Suite -======================================= -Random Seed: 1600732080 -Will run 4 of 4 specs - -STEP: bootstrapping test environment -2020-09-21T16:48:00.541-0700 DEBUG controller-runtime.test-env starting control plane {"api server flags": ["--advertise-address=127.0.0.1", "--etcd-servers={{ if .EtcdURL }}{{ .EtcdURL.String }}{{ end }}", "--cert-dir={{ .CertDir }}", "--insecure-port={{ if .URL }}{{ .URL.Port }}{{ end }}", "--insecure-bind-address={{ if .URL }}{{ .URL.Hostname }}{{ end }}", "--secure-port={{ if .SecurePort }}{{ .SecurePort }}{{ end }}", "--admission-control=AlwaysAdmit", "--service-cluster-ip-range=10.0.0.0/24"]} -2020-09-21T16:48:19.832-0700 DEBUG controller-runtime.test-env installing CRDs -2020-09-21T16:48:19.832-0700 DEBUG controller-runtime.test-env reading CRDs from path {"path": "../../../../config/crd"} -2020-09-21T16:48:19.833-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "kustomization.yaml"} -2020-09-21T16:48:20.172-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "serving.kubeflow.org_inferenceservices.yaml"} -2020-09-21T16:48:20.173-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "serving.kubeflow.org_trainedmodels.yaml"} -2020-09-21T16:48:20.173-0700 DEBUG controller-runtime.test-env reading CRDs from path {"path": "../../../../test/crds"} -2020-09-21T16:48:20.174-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "istio_virtualservice.yaml"} -2020-09-21T16:48:20.174-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "knative_configuration.yaml"} -2020-09-21T16:48:20.174-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "knative_route.yaml"} -2020-09-21T16:48:20.175-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "knative_service.yaml"} -2020-09-21T16:48:20.175-0700 DEBUG controller-runtime.test-env installing CRD {"crd": "inferenceservices.serving.kubeflow.org"} -Failure [21.399 seconds] -[BeforeSuite] BeforeSuite  -/Users/tommyli/go/src/github.com/kubeflow/kfserving/pkg/controller/v1beta1/inferenceservice/suite_test.go:48 - - Unexpected error: - <*errors.StatusError | 0xc0000c6320>: { - ErrStatus: { - TypeMeta: {Kind: "", APIVersion: ""}, - ListMeta: { - SelfLink: "", - ResourceVersion: "", - Continue: "", - RemainingItemCount: nil, - }, - Status: "Failure", - Message: "CustomResourceDefinition.apiextensions.k8s.io \"inferenceservices.serving.kubeflow.org\" is invalid: [spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items: Required value: must be specified]", - Reason: "Invalid", - Details: { - Name: "inferenceservices.serving.kubeflow.org", - Group: "apiextensions.k8s.io", - Kind: "CustomResourceDefinition", - UID: "", - Causes: [ - { - Type: "FieldValueRequired", - Message: "Required value: must be array if x-kubernetes-list-type is specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be array if x-kubernetes-list-type is specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items", - }, - ], - RetryAfterSeconds: 0, - }, - Code: 422, - }, - } - CustomResourceDefinition.apiextensions.k8s.io "inferenceservices.serving.kubeflow.org" is invalid: [spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items: Required value: must be specified] - occurred - - /Users/tommyli/go/src/github.com/kubeflow/kfserving/pkg/controller/v1beta1/inferenceservice/suite_test.go:54 ------------------------------- - - -Ran 4 of 0 Specs in 21.510 seconds -FAIL! -- 0 Passed | 4 Failed | 0 Pending | 0 Skipped ---- FAIL: TestV1beta1APIs (21.51s) -FAIL -coverage: 0.0% of statements -FAIL github.com/kubeflow/kfserving/pkg/controller/v1beta1/inferenceservice 24.748s -? github.com/kubeflow/kfserving/pkg/controller/v1beta1/inferenceservice/components [no test files] -? github.com/kubeflow/kfserving/pkg/controller/v1beta1/inferenceservice/reconcilers/ingress [no test files] -? github.com/kubeflow/kfserving/pkg/controller/v1beta1/inferenceservice/reconcilers/knative [no test files] -Running Suite: v1beta1 Controller Suite -======================================= -Random Seed: 1600732081 -Will run 2 of 2 specs - -STEP: bootstrapping test environment -2020-09-21T16:48:01.313-0700 DEBUG controller-runtime.test-env starting control plane {"api server flags": ["--advertise-address=127.0.0.1", "--etcd-servers={{ if .EtcdURL }}{{ .EtcdURL.String }}{{ end }}", "--cert-dir={{ .CertDir }}", "--insecure-port={{ if .URL }}{{ .URL.Port }}{{ end }}", "--insecure-bind-address={{ if .URL }}{{ .URL.Hostname }}{{ end }}", "--secure-port={{ if .SecurePort }}{{ .SecurePort }}{{ end }}", "--admission-control=AlwaysAdmit", "--service-cluster-ip-range=10.0.0.0/24"]} -2020-09-21T16:48:18.941-0700 DEBUG controller-runtime.test-env installing CRDs -2020-09-21T16:48:18.941-0700 DEBUG controller-runtime.test-env reading CRDs from path {"path": "../../../../test/crds"} -2020-09-21T16:48:18.969-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "istio_virtualservice.yaml"} -2020-09-21T16:48:18.970-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "knative_configuration.yaml"} -2020-09-21T16:48:18.971-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "knative_route.yaml"} -2020-09-21T16:48:18.971-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "knative_service.yaml"} -2020-09-21T16:48:18.971-0700 DEBUG controller-runtime.test-env reading CRDs from path {"path": "../../../../config/crd"} -2020-09-21T16:48:18.972-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "kustomization.yaml"} -2020-09-21T16:48:19.086-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "serving.kubeflow.org_inferenceservices.yaml"} -2020-09-21T16:48:19.087-0700 DEBUG controller-runtime.test-env read CRDs from file {"file": "serving.kubeflow.org_trainedmodels.yaml"} -2020-09-21T16:48:19.087-0700 DEBUG controller-runtime.test-env installing CRD {"crd": "virtualservices.networking.istio.io"} -2020-09-21T16:48:19.189-0700 DEBUG controller-runtime.test-env installing CRD {"crd": "configurations.serving.knative.dev"} -2020-09-21T16:48:19.271-0700 DEBUG controller-runtime.test-env installing CRD {"crd": "routes.serving.knative.dev"} -2020-09-21T16:48:19.334-0700 DEBUG controller-runtime.test-env installing CRD {"crd": "services.serving.knative.dev"} -2020-09-21T16:48:19.371-0700 DEBUG controller-runtime.test-env installing CRD {"crd": "inferenceservices.serving.kubeflow.org"} -Failure [19.120 seconds] -[BeforeSuite] BeforeSuite  -/Users/tommyli/go/src/github.com/kubeflow/kfserving/pkg/controller/v1beta1/trainedmodel/suite_test.go:53 - - Unexpected error: - <*errors.StatusError | 0xc000356000>: { - ErrStatus: { - TypeMeta: {Kind: "", APIVersion: ""}, - ListMeta: { - SelfLink: "", - ResourceVersion: "", - Continue: "", - RemainingItemCount: nil, - }, - Status: "Failure", - Message: "CustomResourceDefinition.apiextensions.k8s.io \"inferenceservices.serving.kubeflow.org\" is invalid: [spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items: Required value: must be specified]", - Reason: "Invalid", - Details: { - Name: "inferenceservices.serving.kubeflow.org", - Group: "apiextensions.k8s.io", - Kind: "CustomResourceDefinition", - UID: "", - Causes: [ - { - Type: "FieldValueRequired", - Message: "Required value: must be array if x-kubernetes-list-type is specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be array if x-kubernetes-list-type is specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be undefined to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be false to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type", - }, - { - Type: "FieldValueForbidden", - Message: "Forbidden: must be empty to be structural", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type", - }, - { - Type: "FieldValueRequired", - Message: "Required value: must be specified", - Field: "spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items", - }, - ], - RetryAfterSeconds: 0, - }, - Code: 422, - }, - } - CustomResourceDefinition.apiextensions.k8s.io "inferenceservices.serving.kubeflow.org" is invalid: [spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].type: Required value: must be array if x-kubernetes-list-type is specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[preference].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.properties[matchFields].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[nodeAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].properties[nodeSelectorTerms].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[podAffinityTerm].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[weight].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[preferredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[namespaces].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[affinity].properties[podAntiAffinity].properties[requiredDuringSchedulingIgnoredDuringExecution].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[containers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[nameservers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[options].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[dnsConfig].properties[searches].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[targetContainerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[ephemeralContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[hostnames].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.properties[ip].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[hostAliases].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[imagePullSecrets].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[args].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[configMapRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[prefix].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[envFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[configMapKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].properties[secretKeyRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[valueFrom].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[env].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[imagePullPolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[postStart].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].properties[preStop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[lifecycle].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[livenessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[containerPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostIP].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[hostPort].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.properties[protocol].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[ports].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[readinessProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[limits].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].properties[requests].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[resources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[allowPrivilegeEscalation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[add].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].properties[drop].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[capabilities].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[privileged].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[procMount].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[readOnlyRootFilesystem].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsGroup].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsNonRoot].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[runAsUser].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[level].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[role].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[seLinuxOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpecName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[gmsaCredentialSpec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].properties[runAsUserName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].properties[windowsOptions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[securityContext].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].properties[command].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[exec].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[failureThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[httpHeaders].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].properties[scheme].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[httpGet].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[initialDelaySeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[periodSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[successThreshold].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[host].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].properties[port].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[tcpSocket].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].properties[timeoutSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[startupProbe].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdinOnce].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[stdin].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[terminationMessagePolicy].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[tty].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[devicePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeDevices].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[mountPropagation].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPathExpr].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.properties[subPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[volumeMounts].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.properties[workingDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[initContainers].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[overhead].additionalProperties.allOf[1].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.properties[conditionType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[readinessGates].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[supplementalGroups].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[securityContext].properties[sysctls].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[effect].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[tolerationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.properties[value].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[tolerations].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[0].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[operator].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.properties[values].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchExpressions].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].properties[matchLabels].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[labelSelector].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[maxSkew].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[topologyKey].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.properties[whenUnsatisfiable].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-map-keys: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].allOf[1].x-kubernetes-list-type: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[topologySpreadConstraints].items: Required value: must be specified, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[0].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[awsElasticBlockStore].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[cachingMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[diskURI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[kind].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].properties[shareName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[azureFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretFile].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cephfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[cinder].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[nodePublishSecretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].properties[volumeAttributes].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[csi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[medium].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].properties[sizeLimit].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[emptyDir].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[targetWWNs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].properties[wwids].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[fc].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[driver].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].additionalProperties: Forbidden: must be undefined to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[options].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flexVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].properties[datasetUUID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[flocker].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[partition].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[pdName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gcePersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[directory].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[repository].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].properties[revision].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[gitRepo].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[endpoints].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[glusterfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].properties[type].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[hostPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthDiscovery].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[chapAuthSession].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[initiatorName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iqn].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[iscsiInterface].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[lun].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[portals].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].properties[targetPortal].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[iscsi].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].properties[server].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[nfs].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[claimName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[persistentVolumeClaim].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].properties[pdID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[photonPersistentDisk].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].properties[volumeID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[portworxVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[configMap].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[apiVersion].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].properties[fieldPath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[fieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[containerName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[0].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].anyOf[1].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[divisor].x-kubernetes-int-or-string: Forbidden: must be false to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].properties[resource].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.properties[resourceFieldRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[downwardAPI].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[audience].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[expirationSeconds].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.properties[serviceAccountToken].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].properties[sources].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[projected].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[group].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[registry].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[tenant].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].properties[volume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[quobyte].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[image].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[keyring].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[monitors].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[pool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].properties[user].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[rbd].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[gateway].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[protectionDomain].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[sslEnabled].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storageMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[storagePool].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[system].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[scaleIO].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[defaultMode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[key].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[mode].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.properties[path].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[items].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[optional].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].properties[secretName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[secret].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[readOnly].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].properties[name].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[secretRef].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].properties[volumeNamespace].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[storageos].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[fsType].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyID].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[storagePolicyName].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].properties[volumePath].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.properties[vsphereVolume].type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].allOf[1].items.type: Forbidden: must be empty to be structural, spec.versions[1].schema.openAPIV3Schema.properties[spec].properties[explainer].properties[volumes].items: Required value: must be specified] - occurred - - /Users/tommyli/go/src/github.com/kubeflow/kfserving/pkg/controller/v1beta1/trainedmodel/suite_test.go:64 ------------------------------- - - -Ran 2 of 0 Specs in 19.325 seconds -FAIL! -- 0 Passed | 2 Failed | 0 Pending | 0 Skipped ---- FAIL: TestAPIs (19.33s) -FAIL -coverage: 0.0% of statements -FAIL github.com/kubeflow/kfserving/pkg/controller/v1beta1/trainedmodel 22.876s -? github.com/kubeflow/kfserving/pkg/controller/v1beta1/trainedmodel/reconcilers/modelconfig [no test files] -? github.com/kubeflow/kfserving/pkg/controller/v1beta1/trainedmodel/sharding [no test files] -? github.com/kubeflow/kfserving/pkg/controller/v1beta1/trainedmodel/sharding/memory [no test files] -ok github.com/kubeflow/kfserving/pkg/credentials 16.094s coverage: 83.3% of statements -ok github.com/kubeflow/kfserving/pkg/credentials/azure 1.813s coverage: 100.0% of statements -ok github.com/kubeflow/kfserving/pkg/credentials/gcs 0.430s coverage: 100.0% of statements -ok github.com/kubeflow/kfserving/pkg/credentials/s3 4.207s coverage: 96.3% of statements -ok github.com/kubeflow/kfserving/pkg/logger 1.307s coverage: 36.8% of statements -ok github.com/kubeflow/kfserving/pkg/modelconfig 0.673s coverage: 88.6% of statements -? github.com/kubeflow/kfserving/pkg/testing [no test files] -ok github.com/kubeflow/kfserving/pkg/utils 0.389s coverage: 76.9% of statements -ok github.com/kubeflow/kfserving/pkg/webhook/admission/pod 5.782s coverage: 51.7% of statements -? github.com/kubeflow/kfserving/cmd/agent [no test files] -? github.com/kubeflow/kfserving/cmd/batcher [no test files] -? github.com/kubeflow/kfserving/cmd/logger [no test files] -? github.com/kubeflow/kfserving/cmd/manager [no test files] -? github.com/kubeflow/kfserving/cmd/spec-gen [no test files] -FAIL From cb3f00e3d192ae679be3799c3d5e530650c671e8 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Tue, 22 Sep 2020 15:47:14 -0700 Subject: [PATCH 25/32] update e2e test to match with the v1beta1 controller changes --- test/e2e/explainer/test_aix_explainer.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/e2e/explainer/test_aix_explainer.py b/test/e2e/explainer/test_aix_explainer.py index 3a678d618f..df9b26c699 100644 --- a/test/e2e/explainer/test_aix_explainer.py +++ b/test/e2e/explainer/test_aix_explainer.py @@ -13,6 +13,7 @@ # limitations under the License. import logging +import os from kubernetes import client @@ -36,7 +37,7 @@ logging.basicConfig(level=logging.INFO) api_version = constants.KFSERVING_GROUP + '/' + constants.KFSERVING_VERSION -KFServing = KFServingClient(config_file="~/.kube/config") +KFServing = KFServingClient(config_file=os.environ.get("KUBECONFIG", "~/.kube/config")) def test_tabular_explainer(): @@ -71,7 +72,7 @@ def test_tabular_explainer(): KFServing.wait_isvc_ready(service_name, namespace=KFSERVING_TEST_NAMESPACE, timeout_seconds=720) except RuntimeError as e: logging.info(KFServing.api_instance.get_namespaced_custom_object("serving.knative.dev", "v1", - KFSERVING_TEST_NAMESPACE, "services", service_name + "-predictor-default")) + KFSERVING_TEST_NAMESPACE, "services", service_name + "-predictor")) pods = KFServing.core_api.list_namespaced_pod(KFSERVING_TEST_NAMESPACE, label_selector='serving.kubeflow.org/inferenceservice={}'.format(service_name)) for pod in pods.items: From afdeadb90c9e0429f023c23b51a4a8e1654d7de7 Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Wed, 23 Sep 2020 09:44:19 -0700 Subject: [PATCH 26/32] Fix logging --- python/aixexplainer/aixserver/model.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/python/aixexplainer/aixserver/model.py b/python/aixexplainer/aixserver/model.py index c83bad0349..58a1d33760 100644 --- a/python/aixexplainer/aixserver/model.py +++ b/python/aixexplainer/aixserver/model.py @@ -14,6 +14,7 @@ from typing import Dict import kfserving +import logging import numpy as np from aix360.algorithms.lime import LimeImageExplainer from lime.wrappers.scikit_image import SegmentationAlgorithm @@ -23,7 +24,6 @@ class AIXModel(kfserving.KFModel): # pylint:disable=c-extension-no-member def __init__(self, name: str, predictor_host: str, segm_alg: str, num_samples: str, top_labels: str, min_weight: str, positive_only: str, explainer_type: str): super().__init__(name) - print("INIT") self.name = name self.top_labels = int(top_labels) self.num_samples = int(num_samples) @@ -37,7 +37,6 @@ def __init__(self, name: str, predictor_host: str, segm_alg: str, num_samples: s self.ready = False def load(self): - print("LOADED") self.ready = True def _predict(self, input_im): @@ -48,10 +47,10 @@ def _predict(self, input_im): return predictions['predictions'] def explain(self, request: Dict) -> Dict: - print("Explaining now") instances = request["instances"] try: inputs = np.array(instances[0]) + logging.info("Calling explain on image of shape %s", (inputs.shape,)) except Exception as err: raise Exception( "Failed to initialize NumPy array from inputs: %s, %s" % (err, instances)) From 9f13ca9728f4afae798cd63f61c0bb3e3719ed19 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Wed, 23 Sep 2020 10:36:28 -0700 Subject: [PATCH 27/32] address comments on ci config --- config/overlays/test/configmap/inferenceservice.yaml | 4 ++++ test/e2e/explainer/test_aix_explainer.py | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/config/overlays/test/configmap/inferenceservice.yaml b/config/overlays/test/configmap/inferenceservice.yaml index cb0a4f1bc6..dba280733f 100644 --- a/config/overlays/test/configmap/inferenceservice.yaml +++ b/config/overlays/test/configmap/inferenceservice.yaml @@ -41,6 +41,10 @@ data: "alibi": { "image" : "gcr.io/kubeflow-ci/kfserving/alibi-explainer", "defaultImageVersion": "latest" + }, + "aix": { + "image" : "gcr.io/kubeflow-ci/kfserving/aix-explainer", + "defaultImageVersion": "latest" } } storageInitializer: |- diff --git a/test/e2e/explainer/test_aix_explainer.py b/test/e2e/explainer/test_aix_explainer.py index df9b26c699..6b1570554a 100644 --- a/test/e2e/explainer/test_aix_explainer.py +++ b/test/e2e/explainer/test_aix_explainer.py @@ -72,7 +72,7 @@ def test_tabular_explainer(): KFServing.wait_isvc_ready(service_name, namespace=KFSERVING_TEST_NAMESPACE, timeout_seconds=720) except RuntimeError as e: logging.info(KFServing.api_instance.get_namespaced_custom_object("serving.knative.dev", "v1", - KFSERVING_TEST_NAMESPACE, "services", service_name + "-predictor")) + KFSERVING_TEST_NAMESPACE, "services", service_name + "-predictor-default")) pods = KFServing.core_api.list_namespaced_pod(KFSERVING_TEST_NAMESPACE, label_selector='serving.kubeflow.org/inferenceservice={}'.format(service_name)) for pod in pods.items: From 645eca3cc7fc264f65822063580607304a6e6550 Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Fri, 25 Sep 2020 08:14:22 -0700 Subject: [PATCH 28/32] Make aixexplainer account for asynchronous predict calls --- .../explanation/aix/mnist/rfserver/rfserver/model.py | 10 +++++----- python/aixexplainer/aixserver/__main__.py | 2 +- python/aixexplainer/aixserver/model.py | 12 +++++++----- python/aixexplainer/setup.py | 3 ++- 4 files changed, 15 insertions(+), 12 deletions(-) diff --git a/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py b/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py index 3eb0397828..dca61f994b 100644 --- a/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py +++ b/docs/samples/explanation/aix/mnist/rfserver/rfserver/model.py @@ -13,6 +13,7 @@ # limitations under the License. import os +import logging from typing import Dict import pickle @@ -38,25 +39,24 @@ def transform(self,X): class RFModel(kfserving.KFModel): #pylint:disable=c-extension-no-member def __init__(self, name: str): super().__init__(name) - print("INIT") self.name = name self.ready = False - def load(self): + def load(self) -> bool: with open('../rfmodel.pickle', 'rb') as f: rf = pickle.load(f) self.model = rf - print("LOADED") self.ready = True + return self.ready def predict(self, request: Dict) -> Dict: - print("Prediction requested") instances = request["instances"] try: inputs = np.asarray(instances) + logging.info("Calling predict on image of shape %s", (inputs.shape,)) except Exception as e: raise Exception( "Failed to initialize NumPy array from inputs: %s, %s" % (e, instances)) @@ -75,4 +75,4 @@ def predict(self, request: Dict) -> Dict: return {"predictions" : class_preds} except Exception as e: - raise Exception("Failed to predict %s" % e) + raise Exception("Failed to predict: %s" % e) diff --git a/python/aixexplainer/aixserver/__main__.py b/python/aixexplainer/aixserver/__main__.py index 6956d5ba86..0f6322e64f 100644 --- a/python/aixexplainer/aixserver/__main__.py +++ b/python/aixexplainer/aixserver/__main__.py @@ -51,4 +51,4 @@ top_labels=args.top_labels, min_weight=args.min_weight, positive_only=args.positive_only, explainer_type=args.explainer_type) model.load() - kfserving.KFServer().start([model]) + kfserving.KFServer().start([model], nest_asyncio=True) diff --git a/python/aixexplainer/aixserver/model.py b/python/aixexplainer/aixserver/model.py index 58a1d33760..88fe409085 100644 --- a/python/aixexplainer/aixserver/model.py +++ b/python/aixexplainer/aixserver/model.py @@ -13,8 +13,9 @@ # limitations under the License. from typing import Dict -import kfserving +import asyncio import logging +import kfserving import numpy as np from aix360.algorithms.lime import LimeImageExplainer from lime.wrappers.scikit_image import SegmentationAlgorithm @@ -36,15 +37,16 @@ def __init__(self, name: str, predictor_host: str, segm_alg: str, num_samples: s self.explainer_type = explainer_type self.ready = False - def load(self): + def load(self) -> bool: self.ready = True + return self.ready def _predict(self, input_im): - input_im = np.array(input_im) scoring_data = {'instances': input_im.tolist()} - predictions = self.predict(scoring_data) - return predictions['predictions'] + loop = asyncio.get_running_loop() + resp = loop.run_until_complete(self.predict(scoring_data)) + return np.array(resp["predictions"]) def explain(self, request: Dict) -> Dict: instances = request["instances"] diff --git a/python/aixexplainer/setup.py b/python/aixexplainer/setup.py index b9d4c16871..9a7082c94a 100644 --- a/python/aixexplainer/setup.py +++ b/python/aixexplainer/setup.py @@ -31,11 +31,12 @@ python_requires='>3.4', packages=find_packages("aixserver"), install_requires=[ - "kfserving>=0.2.1", + "kfserving>=0.4.0", "argparse >= 1.4.0", "numpy >= 1.8.2", "aix360 >= 0.1.0", "lime >= 0.1.1.37", + "nest_asyncio>=1.4.0" ], tests_require=tests_require, extras_require={'test': tests_require} From eb7625e34a17cba7cb42f6237ac839cdacc417f7 Mon Sep 17 00:00:00 2001 From: Andrew-Butler Date: Fri, 25 Sep 2020 09:10:01 -0700 Subject: [PATCH 29/32] Fix e2e test response parsing --- test/e2e/common/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/e2e/common/utils.py b/test/e2e/common/utils.py index 0c2cf73b00..e6b47923f9 100644 --- a/test/e2e/common/utils.py +++ b/test/e2e/common/utils.py @@ -51,7 +51,7 @@ def explain(service_name, input_json): def explain_aix(service_name, input_json): - return explain_response(service_name, input_json)["data"]["masks"][0] + return explain_response(service_name, input_json)["explanations"]["masks"][0] def explain_response(service_name, input_json): From 15d7444ea0e9ca5912cc94531e4b44cb79887dea Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Fri, 25 Sep 2020 14:09:17 -0700 Subject: [PATCH 30/32] updated generated hack files to align with existing format --- hack/violation_exceptions.list | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hack/violation_exceptions.list b/hack/violation_exceptions.list index 881defd332..1b8f5f4056 100644 --- a/hack/violation_exceptions.list +++ b/hack/violation_exceptions.list @@ -1,4 +1,4 @@ -API rule violation: names_match,github.com/kubeflow/kfserving/pkg/apis/serving/v1alpha2,AIXExplainerSpec,StorageURI +API rule violation: names_match,./pkg/apis/serving/v1alpha2,AIXExplainerSpec,StorageURI API rule violation: names_match,./pkg/apis/serving/v1alpha2,AlibiExplainerSpec,StorageURI API rule violation: names_match,./pkg/apis/serving/v1alpha2,ONNXSpec,StorageURI API rule violation: names_match,./pkg/apis/serving/v1alpha2,PredictorSpec,PyTorch From f7af3ab9959089d1b4a1c905b20cae74ea07fa09 Mon Sep 17 00:00:00 2001 From: Tommy Li Date: Fri, 25 Sep 2020 14:19:51 -0700 Subject: [PATCH 31/32] update samples to use v1beta1 api --- docs/samples/explanation/aix/mnist/README.md | 2 +- .../aix/mnist/aix-explainer-v1alpha2.yaml | 32 +++++++++++++++ .../aix/mnist/aix-explainer-v1beta1.yaml | 19 --------- .../explanation/aix/mnist/aix-explainer.yaml | 41 +++++++------------ 4 files changed, 47 insertions(+), 47 deletions(-) create mode 100644 docs/samples/explanation/aix/mnist/aix-explainer-v1alpha2.yaml delete mode 100644 docs/samples/explanation/aix/mnist/aix-explainer-v1beta1.yaml diff --git a/docs/samples/explanation/aix/mnist/README.md b/docs/samples/explanation/aix/mnist/README.md index f15ea1924b..22834a63d0 100644 --- a/docs/samples/explanation/aix/mnist/README.md +++ b/docs/samples/explanation/aix/mnist/README.md @@ -2,7 +2,7 @@ This is an example of how to explain model outputs using [AIX360](https://github.com/Trusted-AI/AIX360) on KFServing. We will be using mnist, a dataset for handwritten digits, for this model and explain how the model decides the predicted results. -To deploy the inferenceservice +To deploy the inferenceservice with v1beta1 API `kubectl apply -f aix-explainer.yaml` diff --git a/docs/samples/explanation/aix/mnist/aix-explainer-v1alpha2.yaml b/docs/samples/explanation/aix/mnist/aix-explainer-v1alpha2.yaml new file mode 100644 index 0000000000..508af298dd --- /dev/null +++ b/docs/samples/explanation/aix/mnist/aix-explainer-v1alpha2.yaml @@ -0,0 +1,32 @@ +apiVersion: "serving.kubeflow.org/v1alpha2" +kind: "InferenceService" +metadata: + name: "aix-explainer" + namespace: default +spec: + default: + predictor: + custom: + container: + name: predictor + image: aipipeline/rf-predictor:0.4.0 + command: ["python", "-m", "rfserver", "--model_name", "aix-explainer"] + imagePullPolicy: Always + resources: + requests: + memory: "2Gi" + cpu: "1" + limits: + memory: "2Gi" + cpu: "1" + explainer: + aix: + type: LimeImages + config: + num_samples: "100" + top_labels: "10" + min_weight: "0.01" + resources: + requests: + cpu: 1 + memory: 2Gi diff --git a/docs/samples/explanation/aix/mnist/aix-explainer-v1beta1.yaml b/docs/samples/explanation/aix/mnist/aix-explainer-v1beta1.yaml deleted file mode 100644 index e78ff72508..0000000000 --- a/docs/samples/explanation/aix/mnist/aix-explainer-v1beta1.yaml +++ /dev/null @@ -1,19 +0,0 @@ -apiVersion: "serving.kubeflow.org/v1beta1" -kind: "InferenceService" -metadata: - name: "aix-explainer" - namespace: default -spec: - predictor: - containers: - - name: predictor - image: aipipeline/rf-predictor:0.4.0 - command: ["python", "-m", "rfserver", "--model_name", "aix-explainer"] - imagePullPolicy: Always - explainer: - aix: - type: LimeImages - config: - num_samples: "100" - top_labels: "10" - min_weight: "0.01" diff --git a/docs/samples/explanation/aix/mnist/aix-explainer.yaml b/docs/samples/explanation/aix/mnist/aix-explainer.yaml index 508af298dd..e78ff72508 100644 --- a/docs/samples/explanation/aix/mnist/aix-explainer.yaml +++ b/docs/samples/explanation/aix/mnist/aix-explainer.yaml @@ -1,32 +1,19 @@ -apiVersion: "serving.kubeflow.org/v1alpha2" +apiVersion: "serving.kubeflow.org/v1beta1" kind: "InferenceService" metadata: name: "aix-explainer" namespace: default spec: - default: - predictor: - custom: - container: - name: predictor - image: aipipeline/rf-predictor:0.4.0 - command: ["python", "-m", "rfserver", "--model_name", "aix-explainer"] - imagePullPolicy: Always - resources: - requests: - memory: "2Gi" - cpu: "1" - limits: - memory: "2Gi" - cpu: "1" - explainer: - aix: - type: LimeImages - config: - num_samples: "100" - top_labels: "10" - min_weight: "0.01" - resources: - requests: - cpu: 1 - memory: 2Gi + predictor: + containers: + - name: predictor + image: aipipeline/rf-predictor:0.4.0 + command: ["python", "-m", "rfserver", "--model_name", "aix-explainer"] + imagePullPolicy: Always + explainer: + aix: + type: LimeImages + config: + num_samples: "100" + top_labels: "10" + min_weight: "0.01" From d2ce61bd4128d907dbd06a71fc98744dc38543b5 Mon Sep 17 00:00:00 2001 From: Andrew Butler Date: Mon, 28 Sep 2020 11:06:55 -0400 Subject: [PATCH 32/32] Apply suggestions from code review Co-authored-by: Animesh Singh --- docs/samples/explanation/aix/mnist/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/samples/explanation/aix/mnist/README.md b/docs/samples/explanation/aix/mnist/README.md index 22834a63d0..43e1c471bf 100644 --- a/docs/samples/explanation/aix/mnist/README.md +++ b/docs/samples/explanation/aix/mnist/README.md @@ -1,6 +1,6 @@ # Using AIX to get explanations for MNIST classifications -This is an example of how to explain model outputs using [AIX360](https://github.com/Trusted-AI/AIX360) on KFServing. We will be using mnist, a dataset for handwritten digits, for this model and explain how the model decides the predicted results. +This is an example of how to explain model predictions using [AI Explainability 360 (AIX360)](https://ai-explainability-360.org/) on KFServing. We will be using mnist dataset for handwritten digits for this model and explain how the model decides the predicted results. To deploy the inferenceservice with v1beta1 API @@ -36,6 +36,6 @@ python query_explain.py http://${INGRESS_HOST}:${INGRESS_PORT}/v1/models/$MODEL_ ## Troubleshooting -`<504> Gateway Timeout <504>` - the explainer is probably taking to long and not sending a response back quickly enough. Either there aren't enough resources allocated or the number of samples the explainer is allowed to take needs to be reduced. To fix this go to aix-explainer.yaml and increase resources. Or to lower the number of allowed samples go to aix-explainer.yaml and add a flag to `explainer: command:` '--num_samples' (the default number of samples is 1000) +`<504> Gateway Timeout <504>` - the explainer is probably taking too long and not sending a response back quickly enough. Either there aren't enough resources allocated or the number of samples the explainer is allowed to take needs to be reduced. To fix this go to aix-explainer.yaml and increase resources. Or to lower the number of allowed samples go to aix-explainer.yaml and add a flag to `explainer: command:` '--num_samples' (the default number of samples is 1000) If you see `Configuration "aixserver-explainer-default" does not have any ready Revision` the container may have taken too long to download. If you run `kubectl get revision` and see your revision is stuck in `ContainerCreating` try deleting the inferenceservice and redeploying.

G`>#c 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